gui: Update translations and documentation

Pretty sure the intention of the select was for it to be non-blocking.
Not that it will matter almost ever.

.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

.gitignore

@@ -1,4 +1,6 @@
-./syncthing
+syncthing
+!gui/syncthing
+!Godeps/_workspace/src/github.com/syncthing
 syncthing.exe
 *.tar.gz
 *.zip
@@ -9,8 +11,7 @@ files/pidx
 bin
 perfstats*.csv
 coverage.xml
-!gui/scripts/syncthing
-syncthing.md5
-syncthing.exe.md5
+syncthing.sig
 RELEASE
 deb
+lib/auto/gui.files.go

AUTHORS

@@ -1,7 +1,10 @@
 # This is the official list of Syncthing authors for copyright purposes.
 
 Aaron Bieber <qbit@deftly.net>
+Adam Piggott <aD@simplypeachy.co.uk> <simplypeachy@users.noreply.github.com>
+Alessandro G. <alessandro.g89@gmail.com>
 Alexander Graf <register-github@alex-graf.de>
+Anderson Mesquita <andersonvom@gmail.com>
 Andrew Dunham <andrew@du.nham.ca>
 Antony Male <antony.male@gmail.com>
 Arthur Axel fREW Schmidt <frew@afoolishmanifesto.com> <frioux@gmail.com>
@@ -10,6 +13,7 @@ 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>
+Benny Ng <benny.tpng@gmail.com>
 Brandon Philips <brandon@ifup.org>
 Brendan Long <self@brendanlong.com>
 Brian R. Becker <brbecker@gmail.com>
@@ -20,7 +24,9 @@ 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 Harte <daniel@harte.me> <daniel@danielharte.co.uk> <norgeous@users.noreply.github.com>
 Daniel Martí <mvdan@mvdan.cc>
+David Rimmer <dinosore@dbrsoftware.co.uk>
 Denis A. <denisva@gmail.com>
 Dennis Wilson <dw@risu.io>
 Dominik Heidler <dominik@heidler.eu>
@@ -33,7 +39,9 @@ Felix Unterpaintner <bigbear2nd@gmail.com>
 Francois-Xavier Gsell <fxgsell@gmail.com>
 Frank Isemann <frank@isemann.name>
 Gilli Sigurdsson <gilli@vx.is>
+Jaakko Hannikainen <jgke@jgke.fi>
 Jacek Szafarkiewicz <szafar@linux.pl>
+Jake Peterson <jake@acogdev.com>
 Jakob Borg <jakob@nym.se>
 James Patterson <jamespatterson@operamail.com> <jpjp@users.noreply.github.com>
 Jaroslav Malec <dzardacz@gmail.com>
@@ -41,25 +49,41 @@ 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>
+Kelong Cong <kc04bc@gmx.com> <kc1212@users.noreply.github.com>
 Ken'ichi Kamada <kamada@nanohz.org>
+Kevin Allen <kma1660@gmail.com>
+Lars K.W. Gohlke <lkwg82@gmx.de>
+Laurent Etiemble <laurent.etiemble@gmail.com> <laurent.etiemble@monobjc.net>
 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>
+Mateusz Naściszewski <matin1111@wp.pl>
+Matt Burke <mburke@amplify.com> <burkemw3@gmail.com>
+Max Schulze <max.schulze@online.de> <kralo@users.noreply.github.com>
 Michael Jephcote <rewt0r@gmx.com> <Rewt0r@users.noreply.github.com>
+Michael Ploujnikov <ploujj@gmail.com>
 Michael Tilli <pyfisch@gmail.com>
+Nate Morrison <natemorrison@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>
+Scott Klupfel <kluppy@going2blue.com>
 Sergey Mishin <ralder@yandex.ru>
-Stefan Tatschner <stefan@sevenbyte.org>
+Stefan Kuntz <stefan.github@gmail.com> <Stefan.github@gmail.com>
+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>
+Tyler Brazier <tyler@tylerbrazier.com>
 Veeti Paananen <veeti.paananen@rojekti.fi>
+Victor Buinsky <vix_booja@tut.by>
 Vil Brekin <vilbrekin@gmail.com>
+William A. Kennington III <william@wkennington.com>
+Wulf Weich <wweich@users.noreply.github.com> <wweich@gmx.de>
+Yannic A. <eipiminusone+github@gmail.com> <eipiminus1@users.noreply.github.com>

Godeps/Godeps.json

@@ -1,81 +0,0 @@
-{
-	"ImportPath": "github.com/syncthing/syncthing",
-	"GoVersion": "go1.5rc1",
-	"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": "ebcdea63c07327a342f65415bbadc497462b8f1f"
-		},
-		{
-			"ImportPath": "github.com/syndtr/goleveldb/leveldb",
-			"Rev": "b743d92d3215f11c9b5ce8830fafe1f16786adf4"
-		},
-		{
-			"ImportPath": "github.com/thejerf/suture",
-			"Rev": "fc7aaeabdc43fe41c5328efa1479ffea0b820978"
-		},
-		{
-			"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/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/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/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/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/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/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/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/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_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/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/vector_xdr.go

@@ -1,38 +0,0 @@
-// Copyright (C) 2015 The Protocol Authors.
-
-package protocol
-
-// 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())
-	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/syndtr/goleveldb/leveldb/external_test.go

@@ -1,58 +0,0 @@
-// Copyright (c) 2014, 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/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	"github.com/syndtr/goleveldb/leveldb/opt"
-	"github.com/syndtr/goleveldb/leveldb/testutil"
-)
-
-var _ = testutil.Defer(func() {
-	Describe("Leveldb external", func() {
-		o := &opt.Options{
-			DisableBlockCache:      true,
-			BlockRestartInterval:   5,
-			BlockSize:              80,
-			Compression:            opt.NoCompression,
-			OpenFilesCacheCapacity: -1,
-			Strict:                 opt.StrictAll,
-			WriteBuffer:            1000,
-			CompactionTableSize:    2000,
-		}
-
-		Describe("write test", func() {
-			It("should do write correctly", func(done Done) {
-				db := newTestingDB(o, nil, nil)
-				t := testutil.DBTesting{
-					DB:      db,
-					Deleted: testutil.KeyValue_Generate(nil, 500, 1, 50, 5, 5).Clone(),
-				}
-				testutil.DoDBTesting(&t)
-				db.TestClose()
-				done <- true
-			}, 20.0)
-		})
-
-		Describe("read test", func() {
-			testutil.AllKeyValueTesting(nil, nil, func(kv testutil.KeyValue) testutil.DB {
-				// Building the DB.
-				db := newTestingDB(o, nil, nil)
-				kv.IterateShuffled(nil, func(i int, key, value []byte) {
-					err := db.TestPut(key, value)
-					Expect(err).NotTo(HaveOccurred())
-				})
-
-				return db
-			}, func(db testutil.DB) {
-				db.(*testingDB).TestClose()
-			})
-		})
-	})
-})

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage/file_storage.go

@@ -1,543 +0,0 @@
-// Copyright (c) 2012, Suryandaru Triandana <syndtr@gmail.com>
-// All rights reservefs.
-//
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-package storage
-
-import (
-	"errors"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/syndtr/goleveldb/leveldb/util"
-)
-
-var errFileOpen = errors.New("leveldb/storage: file still open")
-
-type fileLock interface {
-	release() error
-}
-
-type fileStorageLock struct {
-	fs *fileStorage
-}
-
-func (lock *fileStorageLock) Release() {
-	fs := lock.fs
-	fs.mu.Lock()
-	defer fs.mu.Unlock()
-	if fs.slock == lock {
-		fs.slock = nil
-	}
-	return
-}
-
-// fileStorage is a file-system backed storage.
-type fileStorage struct {
-	path string
-
-	mu    sync.Mutex
-	flock fileLock
-	slock *fileStorageLock
-	logw  *os.File
-	buf   []byte
-	// Opened file counter; if open < 0 means closed.
-	open int
-	day  int
-}
-
-// OpenFile returns a new filesytem-backed storage implementation with the given
-// path. This also hold a file lock, so any subsequent attempt to open the same
-// path will fail.
-//
-// The storage must be closed after use, by calling Close method.
-func OpenFile(path string) (Storage, error) {
-	if err := os.MkdirAll(path, 0755); err != nil {
-		return nil, err
-	}
-
-	flock, err := newFileLock(filepath.Join(path, "LOCK"))
-	if err != nil {
-		return nil, err
-	}
-
-	defer func() {
-		if err != nil {
-			flock.release()
-		}
-	}()
-
-	rename(filepath.Join(path, "LOG"), filepath.Join(path, "LOG.old"))
-	logw, err := os.OpenFile(filepath.Join(path, "LOG"), os.O_WRONLY|os.O_CREATE, 0644)
-	if err != nil {
-		return nil, err
-	}
-
-	fs := &fileStorage{path: path, flock: flock, logw: logw}
-	runtime.SetFinalizer(fs, (*fileStorage).Close)
-	return fs, nil
-}
-
-func (fs *fileStorage) Lock() (util.Releaser, error) {
-	fs.mu.Lock()
-	defer fs.mu.Unlock()
-	if fs.open < 0 {
-		return nil, ErrClosed
-	}
-	if fs.slock != nil {
-		return nil, ErrLocked
-	}
-	fs.slock = &fileStorageLock{fs: fs}
-	return fs.slock, nil
-}
-
-func itoa(buf []byte, i int, wid int) []byte {
-	var u uint = uint(i)
-	if u == 0 && wid <= 1 {
-		return append(buf, '0')
-	}
-
-	// Assemble decimal in reverse order.
-	var b [32]byte
-	bp := len(b)
-	for ; u > 0 || wid > 0; u /= 10 {
-		bp--
-		wid--
-		b[bp] = byte(u%10) + '0'
-	}
-	return append(buf, b[bp:]...)
-}
-
-func (fs *fileStorage) printDay(t time.Time) {
-	if fs.day == t.Day() {
-		return
-	}
-	fs.day = t.Day()
-	fs.logw.Write([]byte("=============== " + t.Format("Jan 2, 2006 (MST)") + " ===============\n"))
-}
-
-func (fs *fileStorage) doLog(t time.Time, str string) {
-	fs.printDay(t)
-	hour, min, sec := t.Clock()
-	msec := t.Nanosecond() / 1e3
-	// time
-	fs.buf = itoa(fs.buf[:0], hour, 2)
-	fs.buf = append(fs.buf, ':')
-	fs.buf = itoa(fs.buf, min, 2)
-	fs.buf = append(fs.buf, ':')
-	fs.buf = itoa(fs.buf, sec, 2)
-	fs.buf = append(fs.buf, '.')
-	fs.buf = itoa(fs.buf, msec, 6)
-	fs.buf = append(fs.buf, ' ')
-	// write
-	fs.buf = append(fs.buf, []byte(str)...)
-	fs.buf = append(fs.buf, '\n')
-	fs.logw.Write(fs.buf)
-}
-
-func (fs *fileStorage) Log(str string) {
-	t := time.Now()
-	fs.mu.Lock()
-	defer fs.mu.Unlock()
-	if fs.open < 0 {
-		return
-	}
-	fs.doLog(t, str)
-}
-
-func (fs *fileStorage) log(str string) {
-	fs.doLog(time.Now(), str)
-}
-
-func (fs *fileStorage) GetFile(num uint64, t FileType) File {
-	return &file{fs: fs, num: num, t: t}
-}
-
-func (fs *fileStorage) GetFiles(t FileType) (ff []File, err error) {
-	fs.mu.Lock()
-	defer fs.mu.Unlock()
-	if fs.open < 0 {
-		return nil, ErrClosed
-	}
-	dir, err := os.Open(fs.path)
-	if err != nil {
-		return
-	}
-	fnn, err := dir.Readdirnames(0)
-	// Close the dir first before checking for Readdirnames error.
-	if err := dir.Close(); err != nil {
-		fs.log(fmt.Sprintf("close dir: %v", err))
-	}
-	if err != nil {
-		return
-	}
-	f := &file{fs: fs}
-	for _, fn := range fnn {
-		if f.parse(fn) && (f.t&t) != 0 {
-			ff = append(ff, f)
-			f = &file{fs: fs}
-		}
-	}
-	return
-}
-
-func (fs *fileStorage) GetManifest() (f File, err error) {
-	fs.mu.Lock()
-	defer fs.mu.Unlock()
-	if fs.open < 0 {
-		return nil, ErrClosed
-	}
-	dir, err := os.Open(fs.path)
-	if err != nil {
-		return
-	}
-	fnn, err := dir.Readdirnames(0)
-	// Close the dir first before checking for Readdirnames error.
-	if err := dir.Close(); err != nil {
-		fs.log(fmt.Sprintf("close dir: %v", err))
-	}
-	if err != nil {
-		return
-	}
-	// Find latest CURRENT file.
-	var rem []string
-	var pend bool
-	var cerr error
-	for _, fn := range fnn {
-		if strings.HasPrefix(fn, "CURRENT") {
-			pend1 := len(fn) > 7
-			// Make sure it is valid name for a CURRENT file, otherwise skip it.
-			if pend1 {
-				if fn[7] != '.' || len(fn) < 9 {
-					fs.log(fmt.Sprintf("skipping %s: invalid file name", fn))
-					continue
-				}
-				if _, e1 := strconv.ParseUint(fn[8:], 10, 0); e1 != nil {
-					fs.log(fmt.Sprintf("skipping %s: invalid file num: %v", fn, e1))
-					continue
-				}
-			}
-			path := filepath.Join(fs.path, fn)
-			r, e1 := os.OpenFile(path, os.O_RDONLY, 0)
-			if e1 != nil {
-				return nil, e1
-			}
-			b, e1 := ioutil.ReadAll(r)
-			if e1 != nil {
-				r.Close()
-				return nil, e1
-			}
-			f1 := &file{fs: fs}
-			if len(b) < 1 || b[len(b)-1] != '\n' || !f1.parse(string(b[:len(b)-1])) {
-				fs.log(fmt.Sprintf("skipping %s: corrupted or incomplete", fn))
-				if pend1 {
-					rem = append(rem, fn)
-				}
-				if !pend1 || cerr == nil {
-					cerr = &ErrCorrupted{
-						File: fsParseName(filepath.Base(fn)),
-						Err:  errors.New("leveldb/storage: corrupted or incomplete manifest file"),
-					}
-				}
-			} else if f != nil && f1.Num() < f.Num() {
-				fs.log(fmt.Sprintf("skipping %s: obsolete", fn))
-				if pend1 {
-					rem = append(rem, fn)
-				}
-			} else {
-				f = f1
-				pend = pend1
-			}
-			if err := r.Close(); err != nil {
-				fs.log(fmt.Sprintf("close %s: %v", fn, err))
-			}
-		}
-	}
-	// Don't remove any files if there is no valid CURRENT file.
-	if f == nil {
-		if cerr != nil {
-			err = cerr
-		} else {
-			err = os.ErrNotExist
-		}
-		return
-	}
-	// Rename pending CURRENT file to an effective CURRENT.
-	if pend {
-		path := fmt.Sprintf("%s.%d", filepath.Join(fs.path, "CURRENT"), f.Num())
-		if err := rename(path, filepath.Join(fs.path, "CURRENT")); err != nil {
-			fs.log(fmt.Sprintf("CURRENT.%d -> CURRENT: %v", f.Num(), err))
-		}
-	}
-	// Remove obsolete or incomplete pending CURRENT files.
-	for _, fn := range rem {
-		path := filepath.Join(fs.path, fn)
-		if err := os.Remove(path); err != nil {
-			fs.log(fmt.Sprintf("remove %s: %v", fn, err))
-		}
-	}
-	return
-}
-
-func (fs *fileStorage) SetManifest(f File) (err error) {
-	fs.mu.Lock()
-	defer fs.mu.Unlock()
-	if fs.open < 0 {
-		return ErrClosed
-	}
-	f2, ok := f.(*file)
-	if !ok || f2.t != TypeManifest {
-		return ErrInvalidFile
-	}
-	defer func() {
-		if err != nil {
-			fs.log(fmt.Sprintf("CURRENT: %v", err))
-		}
-	}()
-	path := fmt.Sprintf("%s.%d", filepath.Join(fs.path, "CURRENT"), f2.Num())
-	w, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
-	if err != nil {
-		return err
-	}
-	_, err = fmt.Fprintln(w, f2.name())
-	// Close the file first.
-	if err := w.Close(); err != nil {
-		fs.log(fmt.Sprintf("close CURRENT.%d: %v", f2.num, err))
-	}
-	if err != nil {
-		return err
-	}
-	return rename(path, filepath.Join(fs.path, "CURRENT"))
-}
-
-func (fs *fileStorage) Close() error {
-	fs.mu.Lock()
-	defer fs.mu.Unlock()
-	if fs.open < 0 {
-		return ErrClosed
-	}
-	// Clear the finalizer.
-	runtime.SetFinalizer(fs, nil)
-
-	if fs.open > 0 {
-		fs.log(fmt.Sprintf("close: warning, %d files still open", fs.open))
-	}
-	fs.open = -1
-	e1 := fs.logw.Close()
-	err := fs.flock.release()
-	if err == nil {
-		err = e1
-	}
-	return err
-}
-
-type fileWrap struct {
-	*os.File
-	f *file
-}
-
-func (fw fileWrap) Sync() error {
-	if err := fw.File.Sync(); err != nil {
-		return err
-	}
-	if fw.f.Type() == TypeManifest {
-		// Also sync parent directory if file type is manifest.
-		// See: https://code.google.com/p/leveldb/issues/detail?id=190.
-		if err := syncDir(fw.f.fs.path); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (fw fileWrap) Close() error {
-	f := fw.f
-	f.fs.mu.Lock()
-	defer f.fs.mu.Unlock()
-	if !f.open {
-		return ErrClosed
-	}
-	f.open = false
-	f.fs.open--
-	err := fw.File.Close()
-	if err != nil {
-		f.fs.log(fmt.Sprintf("close %s.%d: %v", f.Type(), f.Num(), err))
-	}
-	return err
-}
-
-type file struct {
-	fs   *fileStorage
-	num  uint64
-	t    FileType
-	open bool
-}
-
-func (f *file) Open() (Reader, error) {
-	f.fs.mu.Lock()
-	defer f.fs.mu.Unlock()
-	if f.fs.open < 0 {
-		return nil, ErrClosed
-	}
-	if f.open {
-		return nil, errFileOpen
-	}
-	of, err := os.OpenFile(f.path(), os.O_RDONLY, 0)
-	if err != nil {
-		if f.hasOldName() && os.IsNotExist(err) {
-			of, err = os.OpenFile(f.oldPath(), os.O_RDONLY, 0)
-			if err == nil {
-				goto ok
-			}
-		}
-		return nil, err
-	}
-ok:
-	f.open = true
-	f.fs.open++
-	return fileWrap{of, f}, nil
-}
-
-func (f *file) Create() (Writer, error) {
-	f.fs.mu.Lock()
-	defer f.fs.mu.Unlock()
-	if f.fs.open < 0 {
-		return nil, ErrClosed
-	}
-	if f.open {
-		return nil, errFileOpen
-	}
-	of, err := os.OpenFile(f.path(), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
-	if err != nil {
-		return nil, err
-	}
-	f.open = true
-	f.fs.open++
-	return fileWrap{of, f}, nil
-}
-
-func (f *file) Replace(newfile File) error {
-	f.fs.mu.Lock()
-	defer f.fs.mu.Unlock()
-	if f.fs.open < 0 {
-		return ErrClosed
-	}
-	newfile2, ok := newfile.(*file)
-	if !ok {
-		return ErrInvalidFile
-	}
-	if f.open || newfile2.open {
-		return errFileOpen
-	}
-	return rename(newfile2.path(), f.path())
-}
-
-func (f *file) Type() FileType {
-	return f.t
-}
-
-func (f *file) Num() uint64 {
-	return f.num
-}
-
-func (f *file) Remove() error {
-	f.fs.mu.Lock()
-	defer f.fs.mu.Unlock()
-	if f.fs.open < 0 {
-		return ErrClosed
-	}
-	if f.open {
-		return errFileOpen
-	}
-	err := os.Remove(f.path())
-	if err != nil {
-		f.fs.log(fmt.Sprintf("remove %s.%d: %v", f.Type(), f.Num(), err))
-	}
-	// Also try remove file with old name, just in case.
-	if f.hasOldName() {
-		if e1 := os.Remove(f.oldPath()); !os.IsNotExist(e1) {
-			f.fs.log(fmt.Sprintf("remove %s.%d: %v (old name)", f.Type(), f.Num(), err))
-			err = e1
-		}
-	}
-	return err
-}
-
-func (f *file) hasOldName() bool {
-	return f.t == TypeTable
-}
-
-func (f *file) oldName() string {
-	switch f.t {
-	case TypeTable:
-		return fmt.Sprintf("%06d.sst", f.num)
-	}
-	return f.name()
-}
-
-func (f *file) oldPath() string {
-	return filepath.Join(f.fs.path, f.oldName())
-}
-
-func (f *file) name() string {
-	switch f.t {
-	case TypeManifest:
-		return fmt.Sprintf("MANIFEST-%06d", f.num)
-	case TypeJournal:
-		return fmt.Sprintf("%06d.log", f.num)
-	case TypeTable:
-		return fmt.Sprintf("%06d.ldb", f.num)
-	case TypeTemp:
-		return fmt.Sprintf("%06d.tmp", f.num)
-	default:
-		panic("invalid file type")
-	}
-}
-
-func (f *file) path() string {
-	return filepath.Join(f.fs.path, f.name())
-}
-
-func fsParseName(name string) *FileInfo {
-	fi := &FileInfo{}
-	var tail string
-	_, err := fmt.Sscanf(name, "%d.%s", &fi.Num, &tail)
-	if err == nil {
-		switch tail {
-		case "log":
-			fi.Type = TypeJournal
-		case "ldb", "sst":
-			fi.Type = TypeTable
-		case "tmp":
-			fi.Type = TypeTemp
-		default:
-			return nil
-		}
-		return fi
-	}
-	n, _ := fmt.Sscanf(name, "MANIFEST-%d%s", &fi.Num, &tail)
-	if n == 1 {
-		fi.Type = TypeManifest
-		return fi
-	}
-	return nil
-}
-
-func (f *file) parse(name string) bool {
-	fi := fsParseName(name)
-	if fi == nil {
-		return false
-	}
-	f.t = fi.Type
-	f.num = fi.Num
-	return true
-}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/storage/mem_storage.go

@@ -1,203 +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 storage
-
-import (
-	"bytes"
-	"os"
-	"sync"
-
-	"github.com/syndtr/goleveldb/leveldb/util"
-)
-
-const typeShift = 3
-
-type memStorageLock struct {
-	ms *memStorage
-}
-
-func (lock *memStorageLock) Release() {
-	ms := lock.ms
-	ms.mu.Lock()
-	defer ms.mu.Unlock()
-	if ms.slock == lock {
-		ms.slock = nil
-	}
-	return
-}
-
-// memStorage is a memory-backed storage.
-type memStorage struct {
-	mu       sync.Mutex
-	slock    *memStorageLock
-	files    map[uint64]*memFile
-	manifest *memFilePtr
-}
-
-// NewMemStorage returns a new memory-backed storage implementation.
-func NewMemStorage() Storage {
-	return &memStorage{
-		files: make(map[uint64]*memFile),
-	}
-}
-
-func (ms *memStorage) Lock() (util.Releaser, error) {
-	ms.mu.Lock()
-	defer ms.mu.Unlock()
-	if ms.slock != nil {
-		return nil, ErrLocked
-	}
-	ms.slock = &memStorageLock{ms: ms}
-	return ms.slock, nil
-}
-
-func (*memStorage) Log(str string) {}
-
-func (ms *memStorage) GetFile(num uint64, t FileType) File {
-	return &memFilePtr{ms: ms, num: num, t: t}
-}
-
-func (ms *memStorage) GetFiles(t FileType) ([]File, error) {
-	ms.mu.Lock()
-	var ff []File
-	for x, _ := range ms.files {
-		num, mt := x>>typeShift, FileType(x)&TypeAll
-		if mt&t == 0 {
-			continue
-		}
-		ff = append(ff, &memFilePtr{ms: ms, num: num, t: mt})
-	}
-	ms.mu.Unlock()
-	return ff, nil
-}
-
-func (ms *memStorage) GetManifest() (File, error) {
-	ms.mu.Lock()
-	defer ms.mu.Unlock()
-	if ms.manifest == nil {
-		return nil, os.ErrNotExist
-	}
-	return ms.manifest, nil
-}
-
-func (ms *memStorage) SetManifest(f File) error {
-	fm, ok := f.(*memFilePtr)
-	if !ok || fm.t != TypeManifest {
-		return ErrInvalidFile
-	}
-	ms.mu.Lock()
-	ms.manifest = fm
-	ms.mu.Unlock()
-	return nil
-}
-
-func (*memStorage) Close() error { return nil }
-
-type memReader struct {
-	*bytes.Reader
-	m *memFile
-}
-
-func (mr *memReader) Close() error {
-	return mr.m.Close()
-}
-
-type memFile struct {
-	bytes.Buffer
-	ms   *memStorage
-	open bool
-}
-
-func (*memFile) Sync() error { return nil }
-func (m *memFile) Close() error {
-	m.ms.mu.Lock()
-	m.open = false
-	m.ms.mu.Unlock()
-	return nil
-}
-
-type memFilePtr struct {
-	ms  *memStorage
-	num uint64
-	t   FileType
-}
-
-func (p *memFilePtr) x() uint64 {
-	return p.Num()<<typeShift | uint64(p.Type())
-}
-
-func (p *memFilePtr) Open() (Reader, error) {
-	ms := p.ms
-	ms.mu.Lock()
-	defer ms.mu.Unlock()
-	if m, exist := ms.files[p.x()]; exist {
-		if m.open {
-			return nil, errFileOpen
-		}
-		m.open = true
-		return &memReader{Reader: bytes.NewReader(m.Bytes()), m: m}, nil
-	}
-	return nil, os.ErrNotExist
-}
-
-func (p *memFilePtr) Create() (Writer, error) {
-	ms := p.ms
-	ms.mu.Lock()
-	defer ms.mu.Unlock()
-	m, exist := ms.files[p.x()]
-	if exist {
-		if m.open {
-			return nil, errFileOpen
-		}
-		m.Reset()
-	} else {
-		m = &memFile{ms: ms}
-		ms.files[p.x()] = m
-	}
-	m.open = true
-	return m, nil
-}
-
-func (p *memFilePtr) Replace(newfile File) error {
-	p1, ok := newfile.(*memFilePtr)
-	if !ok {
-		return ErrInvalidFile
-	}
-	ms := p.ms
-	ms.mu.Lock()
-	defer ms.mu.Unlock()
-	m1, exist := ms.files[p1.x()]
-	if !exist {
-		return os.ErrNotExist
-	}
-	m0, exist := ms.files[p.x()]
-	if (exist && m0.open) || m1.open {
-		return errFileOpen
-	}
-	delete(ms.files, p1.x())
-	ms.files[p.x()] = m1
-	return nil
-}
-
-func (p *memFilePtr) Type() FileType {
-	return p.t
-}
-
-func (p *memFilePtr) Num() uint64 {
-	return p.num
-}
-
-func (p *memFilePtr) Remove() error {
-	ms := p.ms
-	ms.mu.Lock()
-	defer ms.mu.Unlock()
-	if _, exist := ms.files[p.x()]; exist {
-		delete(ms.files, p.x())
-		return nil
-	}
-	return os.ErrNotExist
-}

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

@@ -1,549 +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 LICENE file.
-
-package leveldb
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"math/rand"
-	"os"
-	"path/filepath"
-	"sync"
-	"testing"
-
-	"github.com/syndtr/goleveldb/leveldb/storage"
-	"github.com/syndtr/goleveldb/leveldb/util"
-)
-
-const typeShift = 4
-
-var (
-	tsErrInvalidFile = errors.New("leveldb.testStorage: invalid file for argument")
-	tsErrFileOpen    = errors.New("leveldb.testStorage: file still open")
-)
-
-var (
-	tsFSEnv   = os.Getenv("GOLEVELDB_USEFS")
-	tsTempdir = os.Getenv("GOLEVELDB_TEMPDIR")
-	tsKeepFS  = tsFSEnv == "2"
-	tsFS      = tsKeepFS || tsFSEnv == "" || tsFSEnv == "1"
-	tsMU      = &sync.Mutex{}
-	tsNum     = 0
-)
-
-type tsOp uint
-
-const (
-	tsOpOpen tsOp = iota
-	tsOpCreate
-	tsOpReplace
-	tsOpRemove
-	tsOpRead
-	tsOpReadAt
-	tsOpWrite
-	tsOpSync
-
-	tsOpNum
-)
-
-type tsLock struct {
-	ts *testStorage
-	r  util.Releaser
-}
-
-func (l tsLock) Release() {
-	l.r.Release()
-	l.ts.t.Log("I: storage lock released")
-}
-
-type tsReader struct {
-	tf tsFile
-	storage.Reader
-}
-
-func (tr tsReader) Read(b []byte) (n int, err error) {
-	ts := tr.tf.ts
-	ts.countRead(tr.tf.Type())
-	if tr.tf.shouldErrLocked(tsOpRead) {
-		return 0, errors.New("leveldb.testStorage: emulated read error")
-	}
-	n, err = tr.Reader.Read(b)
-	if err != nil && err != io.EOF {
-		ts.t.Errorf("E: read error, num=%d type=%v n=%d: %v", tr.tf.Num(), tr.tf.Type(), n, err)
-	}
-	return
-}
-
-func (tr tsReader) ReadAt(b []byte, off int64) (n int, err error) {
-	ts := tr.tf.ts
-	ts.countRead(tr.tf.Type())
-	if tr.tf.shouldErrLocked(tsOpReadAt) {
-		return 0, errors.New("leveldb.testStorage: emulated readAt error")
-	}
-	n, err = tr.Reader.ReadAt(b, off)
-	if err != nil && err != io.EOF {
-		ts.t.Errorf("E: readAt error, num=%d type=%v off=%d n=%d: %v", tr.tf.Num(), tr.tf.Type(), off, n, err)
-	}
-	return
-}
-
-func (tr tsReader) Close() (err error) {
-	err = tr.Reader.Close()
-	tr.tf.close("reader", err)
-	return
-}
-
-type tsWriter struct {
-	tf tsFile
-	storage.Writer
-}
-
-func (tw tsWriter) Write(b []byte) (n int, err error) {
-	if tw.tf.shouldErrLocked(tsOpWrite) {
-		return 0, errors.New("leveldb.testStorage: emulated write error")
-	}
-	n, err = tw.Writer.Write(b)
-	if err != nil {
-		tw.tf.ts.t.Errorf("E: write error, num=%d type=%v n=%d: %v", tw.tf.Num(), tw.tf.Type(), n, err)
-	}
-	return
-}
-
-func (tw tsWriter) Sync() (err error) {
-	ts := tw.tf.ts
-	ts.mu.Lock()
-	for ts.emuDelaySync&tw.tf.Type() != 0 {
-		ts.cond.Wait()
-	}
-	ts.mu.Unlock()
-	if tw.tf.shouldErrLocked(tsOpSync) {
-		return errors.New("leveldb.testStorage: emulated sync error")
-	}
-	err = tw.Writer.Sync()
-	if err != nil {
-		tw.tf.ts.t.Errorf("E: sync error, num=%d type=%v: %v", tw.tf.Num(), tw.tf.Type(), err)
-	}
-	return
-}
-
-func (tw tsWriter) Close() (err error) {
-	err = tw.Writer.Close()
-	tw.tf.close("writer", err)
-	return
-}
-
-type tsFile struct {
-	ts *testStorage
-	storage.File
-}
-
-func (tf tsFile) x() uint64 {
-	return tf.Num()<<typeShift | uint64(tf.Type())
-}
-
-func (tf tsFile) shouldErr(op tsOp) bool {
-	return tf.ts.shouldErr(tf, op)
-}
-
-func (tf tsFile) shouldErrLocked(op tsOp) bool {
-	tf.ts.mu.Lock()
-	defer tf.ts.mu.Unlock()
-	return tf.shouldErr(op)
-}
-
-func (tf tsFile) checkOpen(m string) error {
-	ts := tf.ts
-	if writer, ok := ts.opens[tf.x()]; ok {
-		if writer {
-			ts.t.Errorf("E: cannot %s file, num=%d type=%v: a writer still open", m, tf.Num(), tf.Type())
-		} else {
-			ts.t.Errorf("E: cannot %s file, num=%d type=%v: a reader still open", m, tf.Num(), tf.Type())
-		}
-		return tsErrFileOpen
-	}
-	return nil
-}
-
-func (tf tsFile) close(m string, err error) {
-	ts := tf.ts
-	ts.mu.Lock()
-	defer ts.mu.Unlock()
-	if _, ok := ts.opens[tf.x()]; !ok {
-		ts.t.Errorf("E: %s: redudant file closing, num=%d type=%v", m, tf.Num(), tf.Type())
-	} else if err == nil {
-		ts.t.Logf("I: %s: file closed, num=%d type=%v", m, tf.Num(), tf.Type())
-	}
-	delete(ts.opens, tf.x())
-	if err != nil {
-		ts.t.Errorf("E: %s: cannot close file, num=%d type=%v: %v", m, tf.Num(), tf.Type(), err)
-	}
-}
-
-func (tf tsFile) Open() (r storage.Reader, err error) {
-	ts := tf.ts
-	ts.mu.Lock()
-	defer ts.mu.Unlock()
-	err = tf.checkOpen("open")
-	if err != nil {
-		return
-	}
-	if tf.shouldErr(tsOpOpen) {
-		err = errors.New("leveldb.testStorage: emulated open error")
-		return
-	}
-	r, err = tf.File.Open()
-	if err != nil {
-		if ts.ignoreOpenErr&tf.Type() != 0 {
-			ts.t.Logf("I: cannot open file, num=%d type=%v: %v (ignored)", tf.Num(), tf.Type(), err)
-		} else {
-			ts.t.Errorf("E: cannot open file, num=%d type=%v: %v", tf.Num(), tf.Type(), err)
-		}
-	} else {
-		ts.t.Logf("I: file opened, num=%d type=%v", tf.Num(), tf.Type())
-		ts.opens[tf.x()] = false
-		r = tsReader{tf, r}
-	}
-	return
-}
-
-func (tf tsFile) Create() (w storage.Writer, err error) {
-	ts := tf.ts
-	ts.mu.Lock()
-	defer ts.mu.Unlock()
-	err = tf.checkOpen("create")
-	if err != nil {
-		return
-	}
-	if tf.shouldErr(tsOpCreate) {
-		err = errors.New("leveldb.testStorage: emulated create error")
-		return
-	}
-	w, err = tf.File.Create()
-	if err != nil {
-		ts.t.Errorf("E: cannot create file, num=%d type=%v: %v", tf.Num(), tf.Type(), err)
-	} else {
-		ts.t.Logf("I: file created, num=%d type=%v", tf.Num(), tf.Type())
-		ts.opens[tf.x()] = true
-		w = tsWriter{tf, w}
-	}
-	return
-}
-
-func (tf tsFile) Replace(newfile storage.File) (err error) {
-	ts := tf.ts
-	ts.mu.Lock()
-	defer ts.mu.Unlock()
-	err = tf.checkOpen("replace")
-	if err != nil {
-		return
-	}
-	if tf.shouldErr(tsOpReplace) {
-		err = errors.New("leveldb.testStorage: emulated create error")
-		return
-	}
-	err = tf.File.Replace(newfile.(tsFile).File)
-	if err != nil {
-		ts.t.Errorf("E: cannot replace file, num=%d type=%v: %v", tf.Num(), tf.Type(), err)
-	} else {
-		ts.t.Logf("I: file replace, num=%d type=%v", tf.Num(), tf.Type())
-	}
-	return
-}
-
-func (tf tsFile) Remove() (err error) {
-	ts := tf.ts
-	ts.mu.Lock()
-	defer ts.mu.Unlock()
-	err = tf.checkOpen("remove")
-	if err != nil {
-		return
-	}
-	if tf.shouldErr(tsOpRemove) {
-		err = errors.New("leveldb.testStorage: emulated create error")
-		return
-	}
-	err = tf.File.Remove()
-	if err != nil {
-		ts.t.Errorf("E: cannot remove file, num=%d type=%v: %v", tf.Num(), tf.Type(), err)
-	} else {
-		ts.t.Logf("I: file removed, num=%d type=%v", tf.Num(), tf.Type())
-	}
-	return
-}
-
-type testStorage struct {
-	t *testing.T
-	storage.Storage
-	closeFn func() error
-
-	mu   sync.Mutex
-	cond sync.Cond
-	// Open files, true=writer, false=reader
-	opens         map[uint64]bool
-	emuDelaySync  storage.FileType
-	ignoreOpenErr storage.FileType
-	readCnt       uint64
-	readCntEn     storage.FileType
-
-	emuErr         [tsOpNum]storage.FileType
-	emuErrOnce     [tsOpNum]storage.FileType
-	emuRandErr     [tsOpNum]storage.FileType
-	emuRandErrProb int
-	emuErrOnceMap  map[uint64]uint
-	emuRandRand    *rand.Rand
-}
-
-func (ts *testStorage) shouldErr(tf tsFile, op tsOp) bool {
-	if ts.emuErr[op]&tf.Type() != 0 {
-		return true
-	} else if ts.emuRandErr[op]&tf.Type() != 0 || ts.emuErrOnce[op]&tf.Type() != 0 {
-		sop := uint(1) << op
-		eop := ts.emuErrOnceMap[tf.x()]
-		if eop&sop == 0 && (ts.emuRandRand.Int()%ts.emuRandErrProb == 0 || ts.emuErrOnce[op]&tf.Type() != 0) {
-			ts.emuErrOnceMap[tf.x()] = eop | sop
-			ts.t.Logf("I: emulated error: file=%d type=%v op=%v", tf.Num(), tf.Type(), op)
-			return true
-		}
-	}
-	return false
-}
-
-func (ts *testStorage) SetEmuErr(t storage.FileType, ops ...tsOp) {
-	ts.mu.Lock()
-	for _, op := range ops {
-		ts.emuErr[op] = t
-	}
-	ts.mu.Unlock()
-}
-
-func (ts *testStorage) SetEmuErrOnce(t storage.FileType, ops ...tsOp) {
-	ts.mu.Lock()
-	for _, op := range ops {
-		ts.emuErrOnce[op] = t
-	}
-	ts.mu.Unlock()
-}
-
-func (ts *testStorage) SetEmuRandErr(t storage.FileType, ops ...tsOp) {
-	ts.mu.Lock()
-	for _, op := range ops {
-		ts.emuRandErr[op] = t
-	}
-	ts.mu.Unlock()
-}
-
-func (ts *testStorage) SetEmuRandErrProb(prob int) {
-	ts.mu.Lock()
-	ts.emuRandErrProb = prob
-	ts.mu.Unlock()
-}
-
-func (ts *testStorage) DelaySync(t storage.FileType) {
-	ts.mu.Lock()
-	ts.emuDelaySync |= t
-	ts.cond.Broadcast()
-	ts.mu.Unlock()
-}
-
-func (ts *testStorage) ReleaseSync(t storage.FileType) {
-	ts.mu.Lock()
-	ts.emuDelaySync &= ^t
-	ts.cond.Broadcast()
-	ts.mu.Unlock()
-}
-
-func (ts *testStorage) ReadCounter() uint64 {
-	ts.mu.Lock()
-	defer ts.mu.Unlock()
-	return ts.readCnt
-}
-
-func (ts *testStorage) ResetReadCounter() {
-	ts.mu.Lock()
-	ts.readCnt = 0
-	ts.mu.Unlock()
-}
-
-func (ts *testStorage) SetReadCounter(t storage.FileType) {
-	ts.mu.Lock()
-	ts.readCntEn = t
-	ts.mu.Unlock()
-}
-
-func (ts *testStorage) countRead(t storage.FileType) {
-	ts.mu.Lock()
-	if ts.readCntEn&t != 0 {
-		ts.readCnt++
-	}
-	ts.mu.Unlock()
-}
-
-func (ts *testStorage) SetIgnoreOpenErr(t storage.FileType) {
-	ts.ignoreOpenErr = t
-}
-
-func (ts *testStorage) Lock() (r util.Releaser, err error) {
-	r, err = ts.Storage.Lock()
-	if err != nil {
-		ts.t.Logf("W: storage locking failed: %v", err)
-	} else {
-		ts.t.Log("I: storage locked")
-		r = tsLock{ts, r}
-	}
-	return
-}
-
-func (ts *testStorage) Log(str string) {
-	ts.t.Log("L: " + str)
-	ts.Storage.Log(str)
-}
-
-func (ts *testStorage) GetFile(num uint64, t storage.FileType) storage.File {
-	return tsFile{ts, ts.Storage.GetFile(num, t)}
-}
-
-func (ts *testStorage) GetFiles(t storage.FileType) (ff []storage.File, err error) {
-	ff0, err := ts.Storage.GetFiles(t)
-	if err != nil {
-		ts.t.Errorf("E: get files failed: %v", err)
-		return
-	}
-	ff = make([]storage.File, len(ff0))
-	for i, f := range ff0 {
-		ff[i] = tsFile{ts, f}
-	}
-	ts.t.Logf("I: get files, type=0x%x count=%d", int(t), len(ff))
-	return
-}
-
-func (ts *testStorage) GetManifest() (f storage.File, err error) {
-	f0, err := ts.Storage.GetManifest()
-	if err != nil {
-		if !os.IsNotExist(err) {
-			ts.t.Errorf("E: get manifest failed: %v", err)
-		}
-		return
-	}
-	f = tsFile{ts, f0}
-	ts.t.Logf("I: get manifest, num=%d", f.Num())
-	return
-}
-
-func (ts *testStorage) SetManifest(f storage.File) error {
-	tf, ok := f.(tsFile)
-	if !ok {
-		ts.t.Error("E: set manifest failed: type assertion failed")
-		return tsErrInvalidFile
-	} else if tf.Type() != storage.TypeManifest {
-		ts.t.Errorf("E: set manifest failed: invalid file type: %s", tf.Type())
-		return tsErrInvalidFile
-	}
-	err := ts.Storage.SetManifest(tf.File)
-	if err != nil {
-		ts.t.Errorf("E: set manifest failed: %v", err)
-	} else {
-		ts.t.Logf("I: set manifest, num=%d", tf.Num())
-	}
-	return err
-}
-
-func (ts *testStorage) Close() error {
-	ts.CloseCheck()
-	err := ts.Storage.Close()
-	if err != nil {
-		ts.t.Errorf("E: closing storage failed: %v", err)
-	} else {
-		ts.t.Log("I: storage closed")
-	}
-	if ts.closeFn != nil {
-		if err := ts.closeFn(); err != nil {
-			ts.t.Errorf("E: close function: %v", err)
-		}
-	}
-	return err
-}
-
-func (ts *testStorage) CloseCheck() {
-	ts.mu.Lock()
-	if len(ts.opens) == 0 {
-		ts.t.Log("I: all files are closed")
-	} else {
-		ts.t.Errorf("E: %d files still open", len(ts.opens))
-		for x, writer := range ts.opens {
-			num, tt := x>>typeShift, storage.FileType(x)&storage.TypeAll
-			ts.t.Errorf("E: * num=%d type=%v writer=%v", num, tt, writer)
-		}
-	}
-	ts.mu.Unlock()
-}
-
-func newTestStorage(t *testing.T) *testStorage {
-	var stor storage.Storage
-	var closeFn func() error
-	if tsFS {
-		for {
-			tsMU.Lock()
-			num := tsNum
-			tsNum++
-			tsMU.Unlock()
-			tempdir := tsTempdir
-			if tempdir == "" {
-				tempdir = os.TempDir()
-			}
-			path := filepath.Join(tempdir, fmt.Sprintf("goleveldb-test%d0%d0%d", os.Getuid(), os.Getpid(), num))
-			if _, err := os.Stat(path); err != nil {
-				stor, err = storage.OpenFile(path)
-				if err != nil {
-					t.Fatalf("F: cannot create storage: %v", err)
-				}
-				t.Logf("I: storage created: %s", path)
-				closeFn = func() error {
-					for _, name := range []string{"LOG.old", "LOG"} {
-						f, err := os.Open(filepath.Join(path, name))
-						if err != nil {
-							continue
-						}
-						if log, err := ioutil.ReadAll(f); err != nil {
-							t.Logf("---------------------- %s ----------------------", name)
-							t.Logf("cannot read log: %v", err)
-							t.Logf("---------------------- %s ----------------------", name)
-						} else if len(log) > 0 {
-							t.Logf("---------------------- %s ----------------------\n%s", name, string(log))
-							t.Logf("---------------------- %s ----------------------", name)
-						}
-						f.Close()
-					}
-					if t.Failed() {
-						t.Logf("testing failed, test DB preserved at %s", path)
-						return nil
-					}
-					if tsKeepFS {
-						return nil
-					}
-					return os.RemoveAll(path)
-				}
-
-				break
-			}
-		}
-	} else {
-		stor = storage.NewMemStorage()
-	}
-	ts := &testStorage{
-		t:              t,
-		Storage:        stor,
-		closeFn:        closeFn,
-		opens:          make(map[uint64]bool),
-		emuErrOnceMap:  make(map[uint64]uint),
-		emuRandErrProb: 0x999,
-		emuRandRand:    rand.New(rand.NewSource(0xfacedead)),
-	}
-	ts.cond.L = &ts.mu
-	return ts
-}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil/kvtest.go

@@ -1,187 +0,0 @@
-// Copyright (c) 2014, 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 testutil
-
-import (
-	"fmt"
-	"math/rand"
-
-	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/gomega"
-
-	"github.com/syndtr/goleveldb/leveldb/errors"
-	"github.com/syndtr/goleveldb/leveldb/util"
-)
-
-func KeyValueTesting(rnd *rand.Rand, kv KeyValue, p DB, setup func(KeyValue) DB, teardown func(DB)) {
-	if rnd == nil {
-		rnd = NewRand()
-	}
-
-	if p == nil {
-		BeforeEach(func() {
-			p = setup(kv)
-		})
-		if teardown != nil {
-			AfterEach(func() {
-				teardown(p)
-			})
-		}
-	}
-
-	It("Should find all keys with Find", func() {
-		if db, ok := p.(Find); ok {
-			ShuffledIndex(nil, kv.Len(), 1, func(i int) {
-				key_, key, value := kv.IndexInexact(i)
-
-				// Using exact key.
-				rkey, rvalue, err := db.TestFind(key)
-				Expect(err).ShouldNot(HaveOccurred(), "Error for key %q", key)
-				Expect(rkey).Should(Equal(key), "Key")
-				Expect(rvalue).Should(Equal(value), "Value for key %q", key)
-
-				// Using inexact key.
-				rkey, rvalue, err = db.TestFind(key_)
-				Expect(err).ShouldNot(HaveOccurred(), "Error for key %q (%q)", key_, key)
-				Expect(rkey).Should(Equal(key))
-				Expect(rvalue).Should(Equal(value), "Value for key %q (%q)", key_, key)
-			})
-		}
-	})
-
-	It("Should return error if the key is not present", func() {
-		if db, ok := p.(Find); ok {
-			var key []byte
-			if kv.Len() > 0 {
-				key_, _ := kv.Index(kv.Len() - 1)
-				key = BytesAfter(key_)
-			}
-			rkey, _, err := db.TestFind(key)
-			Expect(err).Should(HaveOccurred(), "Find for key %q yield key %q", key, rkey)
-			Expect(err).Should(Equal(errors.ErrNotFound))
-		}
-	})
-
-	It("Should only find exact key with Get", func() {
-		if db, ok := p.(Get); ok {
-			ShuffledIndex(nil, kv.Len(), 1, func(i int) {
-				key_, key, value := kv.IndexInexact(i)
-
-				// Using exact key.
-				rvalue, err := db.TestGet(key)
-				Expect(err).ShouldNot(HaveOccurred(), "Error for key %q", key)
-				Expect(rvalue).Should(Equal(value), "Value for key %q", key)
-
-				// Using inexact key.
-				if len(key_) > 0 {
-					_, err = db.TestGet(key_)
-					Expect(err).Should(HaveOccurred(), "Error for key %q", key_)
-					Expect(err).Should(Equal(errors.ErrNotFound))
-				}
-			})
-		}
-	})
-
-	It("Should only find present key with Has", func() {
-		if db, ok := p.(Has); ok {
-			ShuffledIndex(nil, kv.Len(), 1, func(i int) {
-				key_, key, _ := kv.IndexInexact(i)
-
-				// Using exact key.
-				ret, err := db.TestHas(key)
-				Expect(err).ShouldNot(HaveOccurred(), "Error for key %q", key)
-				Expect(ret).Should(BeTrue(), "False for key %q", key)
-
-				// Using inexact key.
-				if len(key_) > 0 {
-					ret, err = db.TestHas(key_)
-					Expect(err).ShouldNot(HaveOccurred(), "Error for key %q", key_)
-					Expect(ret).ShouldNot(BeTrue(), "True for key %q", key)
-				}
-			})
-		}
-	})
-
-	TestIter := func(r *util.Range, _kv KeyValue) {
-		if db, ok := p.(NewIterator); ok {
-			iter := db.TestNewIterator(r)
-			Expect(iter.Error()).ShouldNot(HaveOccurred())
-
-			t := IteratorTesting{
-				KeyValue: _kv,
-				Iter:     iter,
-			}
-
-			DoIteratorTesting(&t)
-			iter.Release()
-		}
-	}
-
-	It("Should iterates and seeks correctly", func(done Done) {
-		TestIter(nil, kv.Clone())
-		done <- true
-	}, 3.0)
-
-	RandomIndex(rnd, kv.Len(), Min(kv.Len(), 50), func(i int) {
-		type slice struct {
-			r            *util.Range
-			start, limit int
-		}
-
-		key_, _, _ := kv.IndexInexact(i)
-		for _, x := range []slice{
-			{&util.Range{Start: key_, Limit: nil}, i, kv.Len()},
-			{&util.Range{Start: nil, Limit: key_}, 0, i},
-		} {
-			It(fmt.Sprintf("Should iterates and seeks correctly of a slice %d .. %d", x.start, x.limit), func(done Done) {
-				TestIter(x.r, kv.Slice(x.start, x.limit))
-				done <- true
-			}, 3.0)
-		}
-	})
-
-	RandomRange(rnd, kv.Len(), Min(kv.Len(), 50), func(start, limit int) {
-		It(fmt.Sprintf("Should iterates and seeks correctly of a slice %d .. %d", start, limit), func(done Done) {
-			r := kv.Range(start, limit)
-			TestIter(&r, kv.Slice(start, limit))
-			done <- true
-		}, 3.0)
-	})
-}
-
-func AllKeyValueTesting(rnd *rand.Rand, body, setup func(KeyValue) DB, teardown func(DB)) {
-	Test := func(kv *KeyValue) func() {
-		return func() {
-			var p DB
-			if setup != nil {
-				Defer("setup", func() {
-					p = setup(*kv)
-				})
-			}
-			if teardown != nil {
-				Defer("teardown", func() {
-					teardown(p)
-				})
-			}
-			if body != nil {
-				p = body(*kv)
-			}
-			KeyValueTesting(rnd, *kv, p, func(KeyValue) DB {
-				return p
-			}, nil)
-		}
-	}
-
-	Describe("with no key/value (empty)", Test(&KeyValue{}))
-	Describe("with empty key", Test(KeyValue_EmptyKey()))
-	Describe("with empty value", Test(KeyValue_EmptyValue()))
-	Describe("with one key/value", Test(KeyValue_OneKeyValue()))
-	Describe("with big value", Test(KeyValue_BigValue()))
-	Describe("with special key", Test(KeyValue_SpecialKey()))
-	Describe("with multiple key/value", Test(KeyValue_MultipleKeyValue()))
-	Describe("with generated key/value", Test(KeyValue_Generate(nil, 120, 1, 50, 10, 120)))
-}

Godeps/_workspace/src/github.com/syndtr/goleveldb/leveldb/testutil/storage.go

@@ -1,586 +0,0 @@
-// Copyright (c) 2014, 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 testutil
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"sync"
-
-	. "github.com/onsi/gomega"
-
-	"github.com/syndtr/goleveldb/leveldb/storage"
-	"github.com/syndtr/goleveldb/leveldb/util"
-)
-
-var (
-	storageMu     sync.Mutex
-	storageUseFS  bool = true
-	storageKeepFS bool = false
-	storageNum    int
-)
-
-type StorageMode int
-
-const (
-	ModeOpen StorageMode = 1 << iota
-	ModeCreate
-	ModeRemove
-	ModeRead
-	ModeWrite
-	ModeSync
-	ModeClose
-)
-
-const (
-	modeOpen = iota
-	modeCreate
-	modeRemove
-	modeRead
-	modeWrite
-	modeSync
-	modeClose
-
-	modeCount
-)
-
-const (
-	typeManifest = iota
-	typeJournal
-	typeTable
-	typeTemp
-
-	typeCount
-)
-
-const flattenCount = modeCount * typeCount
-
-func flattenType(m StorageMode, t storage.FileType) int {
-	var x int
-	switch m {
-	case ModeOpen:
-		x = modeOpen
-	case ModeCreate:
-		x = modeCreate
-	case ModeRemove:
-		x = modeRemove
-	case ModeRead:
-		x = modeRead
-	case ModeWrite:
-		x = modeWrite
-	case ModeSync:
-		x = modeSync
-	case ModeClose:
-		x = modeClose
-	default:
-		panic("invalid storage mode")
-	}
-	x *= typeCount
-	switch t {
-	case storage.TypeManifest:
-		return x + typeManifest
-	case storage.TypeJournal:
-		return x + typeJournal
-	case storage.TypeTable:
-		return x + typeTable
-	case storage.TypeTemp:
-		return x + typeTemp
-	default:
-		panic("invalid file type")
-	}
-}
-
-func listFlattenType(m StorageMode, t storage.FileType) []int {
-	ret := make([]int, 0, flattenCount)
-	add := func(x int) {
-		x *= typeCount
-		switch {
-		case t&storage.TypeManifest != 0:
-			ret = append(ret, x+typeManifest)
-		case t&storage.TypeJournal != 0:
-			ret = append(ret, x+typeJournal)
-		case t&storage.TypeTable != 0:
-			ret = append(ret, x+typeTable)
-		case t&storage.TypeTemp != 0:
-			ret = append(ret, x+typeTemp)
-		}
-	}
-	switch {
-	case m&ModeOpen != 0:
-		add(modeOpen)
-	case m&ModeCreate != 0:
-		add(modeCreate)
-	case m&ModeRemove != 0:
-		add(modeRemove)
-	case m&ModeRead != 0:
-		add(modeRead)
-	case m&ModeWrite != 0:
-		add(modeWrite)
-	case m&ModeSync != 0:
-		add(modeSync)
-	case m&ModeClose != 0:
-		add(modeClose)
-	}
-	return ret
-}
-
-func packFile(num uint64, t storage.FileType) uint64 {
-	if num>>(64-typeCount) != 0 {
-		panic("overflow")
-	}
-	return num<<typeCount | uint64(t)
-}
-
-func unpackFile(x uint64) (uint64, storage.FileType) {
-	return x >> typeCount, storage.FileType(x) & storage.TypeAll
-}
-
-type emulatedError struct {
-	err error
-}
-
-func (err emulatedError) Error() string {
-	return fmt.Sprintf("emulated storage error: %v", err.err)
-}
-
-type storageLock struct {
-	s *Storage
-	r util.Releaser
-}
-
-func (l storageLock) Release() {
-	l.r.Release()
-	l.s.logI("storage lock released")
-}
-
-type reader struct {
-	f *file
-	storage.Reader
-}
-
-func (r *reader) Read(p []byte) (n int, err error) {
-	err = r.f.s.emulateError(ModeRead, r.f.Type())
-	if err == nil {
-		r.f.s.stall(ModeRead, r.f.Type())
-		n, err = r.Reader.Read(p)
-	}
-	r.f.s.count(ModeRead, r.f.Type(), n)
-	if err != nil && err != io.EOF {
-		r.f.s.logI("read error, num=%d type=%v n=%d err=%v", r.f.Num(), r.f.Type(), n, err)
-	}
-	return
-}
-
-func (r *reader) ReadAt(p []byte, off int64) (n int, err error) {
-	err = r.f.s.emulateError(ModeRead, r.f.Type())
-	if err == nil {
-		r.f.s.stall(ModeRead, r.f.Type())
-		n, err = r.Reader.ReadAt(p, off)
-	}
-	r.f.s.count(ModeRead, r.f.Type(), n)
-	if err != nil && err != io.EOF {
-		r.f.s.logI("readAt error, num=%d type=%v offset=%d n=%d err=%v", r.f.Num(), r.f.Type(), off, n, err)
-	}
-	return
-}
-
-func (r *reader) Close() (err error) {
-	return r.f.doClose(r.Reader)
-}
-
-type writer struct {
-	f *file
-	storage.Writer
-}
-
-func (w *writer) Write(p []byte) (n int, err error) {
-	err = w.f.s.emulateError(ModeWrite, w.f.Type())
-	if err == nil {
-		w.f.s.stall(ModeWrite, w.f.Type())
-		n, err = w.Writer.Write(p)
-	}
-	w.f.s.count(ModeWrite, w.f.Type(), n)
-	if err != nil && err != io.EOF {
-		w.f.s.logI("write error, num=%d type=%v n=%d err=%v", w.f.Num(), w.f.Type(), n, err)
-	}
-	return
-}
-
-func (w *writer) Sync() (err error) {
-	err = w.f.s.emulateError(ModeSync, w.f.Type())
-	if err == nil {
-		w.f.s.stall(ModeSync, w.f.Type())
-		err = w.Writer.Sync()
-	}
-	w.f.s.count(ModeSync, w.f.Type(), 0)
-	if err != nil {
-		w.f.s.logI("sync error, num=%d type=%v err=%v", w.f.Num(), w.f.Type(), err)
-	}
-	return
-}
-
-func (w *writer) Close() (err error) {
-	return w.f.doClose(w.Writer)
-}
-
-type file struct {
-	s *Storage
-	storage.File
-}
-
-func (f *file) pack() uint64 {
-	return packFile(f.Num(), f.Type())
-}
-
-func (f *file) assertOpen() {
-	ExpectWithOffset(2, f.s.opens).NotTo(HaveKey(f.pack()), "File open, num=%d type=%v writer=%v", f.Num(), f.Type(), f.s.opens[f.pack()])
-}
-
-func (f *file) doClose(closer io.Closer) (err error) {
-	err = f.s.emulateError(ModeClose, f.Type())
-	if err == nil {
-		f.s.stall(ModeClose, f.Type())
-	}
-	f.s.mu.Lock()
-	defer f.s.mu.Unlock()
-	if err == nil {
-		ExpectWithOffset(2, f.s.opens).To(HaveKey(f.pack()), "File closed, num=%d type=%v", f.Num(), f.Type())
-		err = closer.Close()
-	}
-	f.s.countNB(ModeClose, f.Type(), 0)
-	writer := f.s.opens[f.pack()]
-	if err != nil {
-		f.s.logISkip(1, "file close failed, num=%d type=%v writer=%v err=%v", f.Num(), f.Type(), writer, err)
-	} else {
-		f.s.logISkip(1, "file closed, num=%d type=%v writer=%v", f.Num(), f.Type(), writer)
-		delete(f.s.opens, f.pack())
-	}
-	return
-}
-
-func (f *file) Open() (r storage.Reader, err error) {
-	err = f.s.emulateError(ModeOpen, f.Type())
-	if err == nil {
-		f.s.stall(ModeOpen, f.Type())
-	}
-	f.s.mu.Lock()
-	defer f.s.mu.Unlock()
-	if err == nil {
-		f.assertOpen()
-		f.s.countNB(ModeOpen, f.Type(), 0)
-		r, err = f.File.Open()
-	}
-	if err != nil {
-		f.s.logI("file open failed, num=%d type=%v err=%v", f.Num(), f.Type(), err)
-	} else {
-		f.s.logI("file opened, num=%d type=%v", f.Num(), f.Type())
-		f.s.opens[f.pack()] = false
-		r = &reader{f, r}
-	}
-	return
-}
-
-func (f *file) Create() (w storage.Writer, err error) {
-	err = f.s.emulateError(ModeCreate, f.Type())
-	if err == nil {
-		f.s.stall(ModeCreate, f.Type())
-	}
-	f.s.mu.Lock()
-	defer f.s.mu.Unlock()
-	if err == nil {
-		f.assertOpen()
-		f.s.countNB(ModeCreate, f.Type(), 0)
-		w, err = f.File.Create()
-	}
-	if err != nil {
-		f.s.logI("file create failed, num=%d type=%v err=%v", f.Num(), f.Type(), err)
-	} else {
-		f.s.logI("file created, num=%d type=%v", f.Num(), f.Type())
-		f.s.opens[f.pack()] = true
-		w = &writer{f, w}
-	}
-	return
-}
-
-func (f *file) Remove() (err error) {
-	err = f.s.emulateError(ModeRemove, f.Type())
-	if err == nil {
-		f.s.stall(ModeRemove, f.Type())
-	}
-	f.s.mu.Lock()
-	defer f.s.mu.Unlock()
-	if err == nil {
-		f.assertOpen()
-		f.s.countNB(ModeRemove, f.Type(), 0)
-		err = f.File.Remove()
-	}
-	if err != nil {
-		f.s.logI("file remove failed, num=%d type=%v err=%v", f.Num(), f.Type(), err)
-	} else {
-		f.s.logI("file removed, num=%d type=%v", f.Num(), f.Type())
-	}
-	return
-}
-
-type Storage struct {
-	storage.Storage
-	closeFn func() error
-
-	lmu sync.Mutex
-	lb  bytes.Buffer
-
-	mu sync.Mutex
-	// Open files, true=writer, false=reader
-	opens         map[uint64]bool
-	counters      [flattenCount]int
-	bytesCounter  [flattenCount]int64
-	emulatedError [flattenCount]error
-	stallCond     sync.Cond
-	stalled       [flattenCount]bool
-}
-
-func (s *Storage) log(skip int, str string) {
-	s.lmu.Lock()
-	defer s.lmu.Unlock()
-	_, file, line, ok := runtime.Caller(skip + 2)
-	if ok {
-		// Truncate file name at last file name separator.
-		if index := strings.LastIndex(file, "/"); index >= 0 {
-			file = file[index+1:]
-		} else if index = strings.LastIndex(file, "\\"); index >= 0 {
-			file = file[index+1:]
-		}
-	} else {
-		file = "???"
-		line = 1
-	}
-	fmt.Fprintf(&s.lb, "%s:%d: ", file, line)
-	lines := strings.Split(str, "\n")
-	if l := len(lines); l > 1 && lines[l-1] == "" {
-		lines = lines[:l-1]
-	}
-	for i, line := range lines {
-		if i > 0 {
-			s.lb.WriteString("\n\t")
-		}
-		s.lb.WriteString(line)
-	}
-	s.lb.WriteByte('\n')
-}
-
-func (s *Storage) logISkip(skip int, format string, args ...interface{}) {
-	pc, _, _, ok := runtime.Caller(skip + 1)
-	if ok {
-		if f := runtime.FuncForPC(pc); f != nil {
-			fname := f.Name()
-			if index := strings.LastIndex(fname, "."); index >= 0 {
-				fname = fname[index+1:]
-			}
-			format = fname + ": " + format
-		}
-	}
-	s.log(skip+1, fmt.Sprintf(format, args...))
-}
-
-func (s *Storage) logI(format string, args ...interface{}) {
-	s.logISkip(1, format, args...)
-}
-
-func (s *Storage) Log(str string) {
-	s.log(1, "Log: "+str)
-	s.Storage.Log(str)
-}
-
-func (s *Storage) Lock() (r util.Releaser, err error) {
-	r, err = s.Storage.Lock()
-	if err != nil {
-		s.logI("storage locking failed, err=%v", err)
-	} else {
-		s.logI("storage locked")
-		r = storageLock{s, r}
-	}
-	return
-}
-
-func (s *Storage) GetFile(num uint64, t storage.FileType) storage.File {
-	return &file{s, s.Storage.GetFile(num, t)}
-}
-
-func (s *Storage) GetFiles(t storage.FileType) (files []storage.File, err error) {
-	rfiles, err := s.Storage.GetFiles(t)
-	if err != nil {
-		s.logI("get files failed, err=%v", err)
-		return
-	}
-	files = make([]storage.File, len(rfiles))
-	for i, f := range rfiles {
-		files[i] = &file{s, f}
-	}
-	s.logI("get files, type=0x%x count=%d", int(t), len(files))
-	return
-}
-
-func (s *Storage) GetManifest() (f storage.File, err error) {
-	manifest, err := s.Storage.GetManifest()
-	if err != nil {
-		if !os.IsNotExist(err) {
-			s.logI("get manifest failed, err=%v", err)
-		}
-		return
-	}
-	s.logI("get manifest, num=%d", manifest.Num())
-	return &file{s, manifest}, nil
-}
-
-func (s *Storage) SetManifest(f storage.File) error {
-	f_, ok := f.(*file)
-	ExpectWithOffset(1, ok).To(BeTrue())
-	ExpectWithOffset(1, f_.Type()).To(Equal(storage.TypeManifest))
-	err := s.Storage.SetManifest(f_.File)
-	if err != nil {
-		s.logI("set manifest failed, err=%v", err)
-	} else {
-		s.logI("set manifest, num=%d", f_.Num())
-	}
-	return err
-}
-
-func (s *Storage) openFiles() string {
-	out := "Open files:"
-	for x, writer := range s.opens {
-		num, t := unpackFile(x)
-		out += fmt.Sprintf("\n · num=%d type=%v writer=%v", num, t, writer)
-	}
-	return out
-}
-
-func (s *Storage) Close() error {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	ExpectWithOffset(1, s.opens).To(BeEmpty(), s.openFiles())
-	err := s.Storage.Close()
-	if err != nil {
-		s.logI("storage closing failed, err=%v", err)
-	} else {
-		s.logI("storage closed")
-	}
-	if s.closeFn != nil {
-		if err1 := s.closeFn(); err1 != nil {
-			s.logI("close func error, err=%v", err1)
-		}
-	}
-	return err
-}
-
-func (s *Storage) countNB(m StorageMode, t storage.FileType, n int) {
-	s.counters[flattenType(m, t)]++
-	s.bytesCounter[flattenType(m, t)] += int64(n)
-}
-
-func (s *Storage) count(m StorageMode, t storage.FileType, n int) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	s.countNB(m, t, n)
-}
-
-func (s *Storage) ResetCounter(m StorageMode, t storage.FileType) {
-	for _, x := range listFlattenType(m, t) {
-		s.counters[x] = 0
-		s.bytesCounter[x] = 0
-	}
-}
-
-func (s *Storage) Counter(m StorageMode, t storage.FileType) (count int, bytes int64) {
-	for _, x := range listFlattenType(m, t) {
-		count += s.counters[x]
-		bytes += s.bytesCounter[x]
-	}
-	return
-}
-
-func (s *Storage) emulateError(m StorageMode, t storage.FileType) error {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	err := s.emulatedError[flattenType(m, t)]
-	if err != nil {
-		return emulatedError{err}
-	}
-	return nil
-}
-
-func (s *Storage) EmulateError(m StorageMode, t storage.FileType, err error) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	for _, x := range listFlattenType(m, t) {
-		s.emulatedError[x] = err
-	}
-}
-
-func (s *Storage) stall(m StorageMode, t storage.FileType) {
-	x := flattenType(m, t)
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	for s.stalled[x] {
-		s.stallCond.Wait()
-	}
-}
-
-func (s *Storage) Stall(m StorageMode, t storage.FileType) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	for _, x := range listFlattenType(m, t) {
-		s.stalled[x] = true
-	}
-}
-
-func (s *Storage) Release(m StorageMode, t storage.FileType) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	for _, x := range listFlattenType(m, t) {
-		s.stalled[x] = false
-	}
-	s.stallCond.Broadcast()
-}
-
-func NewStorage() *Storage {
-	var stor storage.Storage
-	var closeFn func() error
-	if storageUseFS {
-		for {
-			storageMu.Lock()
-			num := storageNum
-			storageNum++
-			storageMu.Unlock()
-			path := filepath.Join(os.TempDir(), fmt.Sprintf("goleveldb-test%d0%d0%d", os.Getuid(), os.Getpid(), num))
-			if _, err := os.Stat(path); os.IsNotExist(err) {
-				stor, err = storage.OpenFile(path)
-				ExpectWithOffset(1, err).NotTo(HaveOccurred(), "creating storage at %s", path)
-				closeFn = func() error {
-					if storageKeepFS {
-						return nil
-					}
-					return os.RemoveAll(path)
-				}
-				break
-			}
-		}
-	} else {
-		stor = storage.NewMemStorage()
-	}
-	s := &Storage{
-		Storage: stor,
-		closeFn: closeFn,
-		opens:   make(map[uint64]bool),
-	}
-	s.stallCond.L = &s.mu
-	return s
-}

Godeps/_workspace/src/github.com/thejerf/suture/.travis.yml

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

ISSUE_TEMPLATE.md

@@ -0,0 +1,24 @@
+If your issue is a support request ("How do I get my devices to connect?"
+or similar), please use the support 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. 
+
+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)
+

NICKS

@@ -1,65 +1,88 @@
 # This file maps email addresses used in commits to nicks used the changelog.
 
-AudriusButkevicius	<audrius.butkevicius@gmail.com>
-Cathryne	<cathryne.linenweaver@gmail.com> <Cathryne@users.noreply.github.com>
-KayoticSully	<kayoticsully@gmail.com>
-LordLandon	<lordlandon@gmail.com>
-Moter8		<moter8@gmail.com>
-Nutomic		<me@nutomic.com>
-Rewt0r		<rewt0r@gmx.com> <Rewt0r@users.noreply.github.com>
-Vilbrekin	<vilbrekin@gmail.com>
-Zillode		<zillode@zillode.be>
+acogdev		<jake@acogdev.com>
 alex2108	<register-github@alex-graf.de>
+alessandro.g89	<alessandro.g89@gmail.com>
+andersonvom	<andersonvom@gmail.com>
 andrew-d	<andrew@du.nham.ca>
 asdil12		<dominik@heidler.eu>
+AudriusButkevicius	<audrius.butkevicius@gmail.com>
 bencurthoys	<ben@bencurthoys.com>
 bigbear2nd	<bigbear2nd@gmail.com>
 brbecker	<brbecker@gmail.com>
 brendanlong	<self@brendanlong.com>
 brgmnn      <dan.arne.bergmann@gmail.com> <brgmnn@users.noreply.github.com>
 bsidhom		<bsidhom@gmail.com>
+buinsky	<vix_booja@tut.by>
+burkemw3	<mburke@amplify.com> <burkemw3@gmail.com>
 calmh		<jakob@nym.se>
 canton7	<antony.male@gmail.com>
+Cathryne	<cathryne.linenweaver@gmail.com> <Cathryne@users.noreply.github.com>
 cdata		<chris@scriptolo.gy>
 cdhowie	<me@chrishowie.com>
 ceh		<emil@hessman.se>
 cqcallaw	<enlightened.despot@gmail.com>
+dinosore	<dinosore@dbrsoftware.co.uk>
 dva	<denisva@gmail.com>
 dzarda		<dzardacz@gmail.com>
+eipiminus1	<eipiminusone+github@gmail.com> <eipiminus1@users.noreply.github.com>
 facastagnini	<federico.castagnini@gmail.com>
 filoozoom	<philippe@schommers.be>
 frioux		<frew@afoolishmanifesto.com> <frioux@gmail.com>
 fti7	<frank@isemann.name>
 gillisig	<gilli@vx.is>
 hadogenes	<szafar@linux.pl>
+ironmig	<kma1660@gmail.com>
 jarlebring	<jarlebring@gmail.com>
 jedie		<github.com@jensdiemer.de> <git@jensdiemer.de>
+jgke	<jgke@jgke.fi>
 jpjp		<jamespatterson@operamail.com> <jpjp@users.noreply.github.com>
 kamadak		<kamada@nanohz.org>
+KayoticSully	<kayoticsully@gmail.com>
 kilburn		<kilburn@la3.org>
+kluppy	<kluppy@going2blue.com>
 kozec		<kozec@kozec.com>
+kralo	<max.schulze@online.de>
 krozycki	<rozycki.karol@gmail.com>
+letiemble	<laurent.etiemble@gmail.com> <laurent.etiemble@monobjc.net>
+LordLandon	<lordlandon@gmail.com>
+lkwg82	<lkwg82@gmx.de>
 marcindziadus	<dziadus.marcin@gmail.com>
 marclaporte <marc@marclaporte.com>
+mateon1	<matin1111@wp.pl>
 mogwa1	<devriesb@gmail.com>
 moshen		<moshen.colin@gmail.com>
+Moter8		<moter8@gmail.com>
 mvdan		<mvdan@mvdan.cc>
+norgeous	<daniel@harte.me> <daniel@danielharte.co.uk> <norgeous@users.noreply.github.com>
+nrm21	<natemorrison@gmail.com>
+Nutomic		<me@nutomic.com>
 pascalj		<github@pascalj.com> <mail@pascal-jungblut.com>
 peterhoeg	<peter@speartail.com>
 philips		<brandon@ifup.org>
 piobpl		<piotrb10@gmail.com>
+plouj	<ploujj@gmail.com>
 pluby		<phill.luby@newredo.com>
 pyfisch		<pyfisch@gmail.com>
 qbit		<qbit@deftly.net>
 ralder		<ralder@yandex.ru>
-rumpelsepp	<stefan@sevenbyte.org>
+Rewt0r		<rewt0r@gmx.com> <Rewt0r@users.noreply.github.com>
+rumpelsepp	<stefan@sevenbyte.org> <rumpelsepp@sevenbyte.org>
 sciurius	<jvromans@squirrel.nl>
 seehuhn		<voss@seehuhn.de>
+simplypeachy	<aD@simplypeachy.co.uk> <simplypeachy@users.noreply.github.com>
 snnd		<dw@risu.io>
+Stefan-Code	<stefan.github@gmail.com> <Stefan.github@gmail.com>
 timabell	<tim@timwise.co.uk>
 tnn2		<tnn@nygren.pp.se>
 tojrobinson	<tully@tojr.org>
+tpng		<benny.tpng@gmail.com>
+tylerbrazier	<tyler@tylerbrazier.com>
 uok		<ueomkail@gmail.com> <uok@users.noreply.github.com>
 veeti		<veeti.paananen@rojekti.fi>
+Vilbrekin	<vilbrekin@gmail.com>
+wkennington	<william@wkennington.com>
 wsgcsysadmin	<e.meitner@willystreet.coo>
+wweich	<wweich@users.noreply.github.com> <wweich@gmx.de>
+Zillode		<zillode@zillode.be>
 zukoo		<fxgsell@gmail.com>

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.

README.md

@@ -1,17 +1,16 @@
-Syncthing
-=========
+# Syncthing
 
-[![Latest Build](http://img.shields.io/jenkins/s/http/build.syncthing.net/syncthing.svg?style=flat-square)](http://build.syncthing.net/job/syncthing/lastBuild/)
-[![API Documentation](http://img.shields.io/badge/api-Godoc-blue.svg?style=flat-square)](http://godoc.org/github.com/syncthing/syncthing)
-[![MPLv2 License](http://img.shields.io/badge/license-MPLv2-blue.svg?style=flat-square)](https://www.mozilla.org/MPL/2.0/)
+[![Latest Build (Official)](https://img.shields.io/jenkins/s/http/build.syncthing.net/syncthing.svg?style=flat-square&label=unix%20build)](http://build.syncthing.net/job/syncthing/lastBuild/)
+[![AppVeyor Build](https://img.shields.io/appveyor/ci/calmh/syncthing/master.svg?style=flat-square&label=windows%20build)](https://ci.appveyor.com/project/calmh/syncthing)
+[![API Documentation](https://img.shields.io/badge/api-Godoc-blue.svg?style=flat-square)](http://godoc.org/github.com/syncthing/syncthing)
+[![MPLv2 License](https://img.shields.io/badge/license-MPLv2-blue.svg?style=flat-square)](https://www.mozilla.org/MPL/2.0/)
 
 This is the Syncthing project which pursues the following goals:
 
  1. Define a protocol for synchronization of a folder between a number of
     collaborating devices. This protocol should be well defined, unambiguous,
     easily understood, free to use, efficient, secure and language neutral.
-    This is called the [Block Exchange
-    Protocol](https://github.com/syncthing/specs/blob/master/BEPv1.md).
+    This is called the [Block Exchange Protocol][1].
 
  2. Provide the reference implementation to demonstrate the usability of
     said protocol. This is the `syncthing` utility. We hope that
@@ -21,38 +20,50 @@ The two are evolving together; the protocol is not to be considered
 stable until Syncthing 1.0 is released, at which point it is locked down
 for incompatible changes.
 
-Getting Started
----------------
+## Getting Started
 
-Take a look at the [getting started
-guide](http://docs.syncthing.net/intro/getting-started.html).
+Take a look at the [getting started guide][2].
 
 There are a few examples for keeping Syncthing running in the background
-on your system in [the etc directory](https://github.com/syncthing/syncthing/blob/master/etc).
+on your system in [the etc directory][3]. There are also several [GUI
+implementations][11] for Windows, Mac and Linux.
 
-There is an IRC channel, `#syncthing` on Freenode, for talking directly
-to developers and users.
+## Getting in Touch
 
-Building
---------
+The first and best point of contact is the [Forum][8]. There is also an IRC
+channel, `#syncthing` on [freenode][4] (with a [web client][9]), for talking
+directly to developers and users. If you've found something that is clearly a
+bug, feel free to report it in the [GitHub issue tracker][10].
 
-Building Syncthing from source is easy, and there's a
-[guide](http://docs.syncthing.net/dev/building.html).
+## Building
+
+Building Syncthing from source is easy, and there's a [guide][5]
 that describes it for both Unix and Windows systems.
 
-Signed Releases
----------------
+## Signed Releases
 
-As of v0.10.15 and onwards, git tags and release binaries are GPG signed
-with the key D26E6ED000654A3E (see https://syncthing.net/security.html).
-For release binaries, MD5 and SHA1 checksums are calculated and signed,
-available in the md5sum.txt.asc and sha1sum.txt.asc files.
+As of v0.10.15 and onwards release binaries are GPG signed with the key
+D26E6ED000654A3E, available from https://syncthing.net/security.html and
+most key servers.
 
-Documentation
-=============
+There is also a built in automatic upgrade mechanism (disabled in some
+distribution channels) which uses a compiled in ECDSA signature. Mac OS
+X binaries are also properly code signed.
 
-Please see the [Syncthing
-documentation site](http://docs.syncthing.net/).
+## Documentation
 
-All code is licensed under the
-[MPLv2 License](https://github.com/syncthing/syncthing/blob/master/LICENSE).
+Please see the [Syncthing documentation site][6].
+
+All code is licensed under the [MPLv2 License][7].
+
+[1]: http://docs.syncthing.net/specs/bep-v1.html
+[2]: http://docs.syncthing.net/intro/getting-started.html
+[3]: https://github.com/syncthing/syncthing/blob/master/etc
+[4]: http://www.freenode.net/irc_servers.shtml
+[5]: http://docs.syncthing.net/dev/building.html
+[6]: http://docs.syncthing.net/
+[7]: https://github.com/syncthing/syncthing/blob/master/LICENSE
+[8]: https://forum.syncthing.net/
+[9]: https://kiwiirc.com/client/irc.freenode.net/#syncthing
+[10]: https://github.com/syncthing/syncthing/issues
+[11]: http://docs.syncthing.net/users/contrib.html#gui-wrappers

appveyor.yaml

@@ -0,0 +1,12 @@
+version: '{branch}-{build}'
+clone_folder: C:\src\github.com\syncthing\syncthing
+init:
+- go version
+environment:
+  GOPATH: C:\
+build_script:
+- go run build.go zip
+test_script:
+- go run build.go test
+artifacts:
+- path: '*.zip'

build.go

@@ -13,7 +13,6 @@ import (
 	"archive/zip"
 	"bytes"
 	"compress/gzip"
-	"crypto/md5"
 	"flag"
 	"fmt"
 	"io"
@@ -27,6 +26,7 @@ import (
 	"runtime"
 	"strconv"
 	"strings"
+	"text/template"
 	"time"
 )
 
@@ -46,6 +46,8 @@ func main() {
 	log.SetOutput(os.Stdout)
 	log.SetFlags(0)
 
+	// If GOPATH isn't set, set it correctly with the assumption that we are
+	// in $GOPATH/src/github.com/syncthing/syncthing.
 	if os.Getenv("GOPATH") == "" {
 		cwd, err := os.Getwd()
 		if err != nil {
@@ -55,6 +57,12 @@ func main() {
 		log.Println("GOPATH is", gopath)
 		os.Setenv("GOPATH", gopath)
 	}
+
+	// We use Go 1.5+ vendoring.
+	os.Setenv("GO15VENDOREXPERIMENT", "1")
+
+	// Set path to $GOPATH/bin:$PATH so that we can for sure find tools we
+	// might have installed during "build.go setup".
 	os.Setenv("PATH", fmt.Sprintf("%s%cbin%c%s", os.Getenv("GOPATH"), os.PathSeparator, os.PathListSeparator, os.Getenv("PATH")))
 
 	flag.StringVar(&goarch, "goarch", runtime.GOARCH, "GOARCH")
@@ -65,7 +73,7 @@ func main() {
 	flag.Parse()
 
 	switch goarch {
-	case "386", "amd64", "arm":
+	case "386", "amd64", "arm", "arm64", "ppc64", "ppc64le":
 		break
 	default:
 		log.Printf("Unknown goarch %q; proceed with caution!", goarch)
@@ -109,13 +117,13 @@ func main() {
 			build(pkg, tags)
 
 		case "test":
-			test("./...")
+			test("./lib/...", "./cmd/...")
 
 		case "bench":
-			bench("./...")
+			bench("./lib/...", "./cmd/...")
 
 		case "assets":
-			assets()
+			rebuildAssets()
 
 		case "xdr":
 			xdr()
@@ -126,9 +134,6 @@ func main() {
 		case "transifex":
 			transifex()
 
-		case "deps":
-			deps()
-
 		case "tar":
 			buildTar()
 
@@ -156,9 +161,9 @@ func main() {
 }
 
 func checkRequiredGoVersion() (float64, bool) {
-	ver := run("go", "version")
-	re := regexp.MustCompile(`go version go(\d+\.\d+)`)
-	if m := re.FindSubmatch(ver); len(m) == 2 {
+	re := regexp.MustCompile(`go(\d+\.\d+)`)
+	ver := runtime.Version()
+	if m := re.FindStringSubmatch(ver); len(m) == 2 {
 		vs := string(m[1])
 		// This is a standard go build. Verify that it's new enough.
 		f, err := strconv.ParseFloat(vs, 64)
@@ -166,7 +171,9 @@ func checkRequiredGoVersion() (float64, bool) {
 			log.Printf("*** Couldn't parse Go version out of %q.\n*** This isn't known to work, proceed on your own risk.", vs)
 			return 0, false
 		}
-		if f < minGoVersion {
+		if f < 1.5 {
+			log.Printf("*** Go version %.01f doesn't support the vendoring mechanism.\n*** Ensure correct dependencies in your $GOPATH.", f)
+		} else if f < minGoVersion {
 			log.Fatalf("*** Go version %.01f is less than required %.01f.\n*** This is known not to work, not proceeding.", f, minGoVersion)
 		}
 		return f, true
@@ -180,23 +187,42 @@ func setup() {
 	runPrint("go", "get", "-v", "golang.org/x/tools/cmd/cover")
 	runPrint("go", "get", "-v", "golang.org/x/tools/cmd/vet")
 	runPrint("go", "get", "-v", "golang.org/x/net/html")
-	runPrint("go", "get", "-v", "github.com/tools/godep")
+	runPrint("go", "get", "-v", "github.com/FiloSottile/gvt")
 	runPrint("go", "get", "-v", "github.com/axw/gocov/gocov")
 	runPrint("go", "get", "-v", "github.com/AlekSi/gocov-xml")
+	runPrint("go", "get", "-v", "bitbucket.org/tebeka/go2xunit")
 }
 
-func test(pkg string) {
-	setBuildEnv()
-	runPrint("go", "test", "-short", "-timeout", "60s", pkg)
+func test(pkgs ...string) {
+	lazyRebuildAssets()
+
+	useRace := runtime.GOARCH == "amd64"
+	switch runtime.GOOS {
+	case "darwin", "linux", "freebsd", "windows":
+	default:
+		useRace = false
+	}
+
+	if useRace {
+		runPrint("go", append([]string{"test", "-short", "-race", "-timeout", "60s"}, pkgs...)...)
+	} else {
+		runPrint("go", append([]string{"test", "-short", "-timeout", "60s"}, pkgs...)...)
+	}
 }
 
-func bench(pkg string) {
-	setBuildEnv()
-	runPrint("go", "test", "-run", "NONE", "-bench", ".", pkg)
+func bench(pkgs ...string) {
+	lazyRebuildAssets()
+	runPrint("go", append([]string{"test", "-run", "NONE", "-bench", "."}, pkgs...)...)
 }
 
 func install(pkg string, tags []string) {
-	os.Setenv("GOBIN", "./bin")
+	lazyRebuildAssets()
+
+	cwd, err := os.Getwd()
+	if err != nil {
+		log.Fatal(err)
+	}
+	os.Setenv("GOBIN", filepath.Join(cwd, "bin"))
 	args := []string{"install", "-v", "-ldflags", ldflags()}
 	if len(tags) > 0 {
 		args = append(args, "-tags", strings.Join(tags, ","))
@@ -205,18 +231,22 @@ func install(pkg string, tags []string) {
 		args = append(args, "-race")
 	}
 	args = append(args, pkg)
-	setBuildEnv()
+
+	os.Setenv("GOOS", goos)
+	os.Setenv("GOARCH", goarch)
 	runPrint("go", args...)
 }
 
 func build(pkg string, tags []string) {
+	lazyRebuildAssets()
+
 	binary := "syncthing"
 	if goos == "windows" {
 		binary += ".exe"
 	}
 
-	rmr(binary, binary+".md5")
-	args := []string{"build", "-ldflags", ldflags()}
+	rmr(binary)
+	args := []string{"build", "-i", "-v", "-ldflags", ldflags()}
 	if len(tags) > 0 {
 		args = append(args, "-tags", strings.Join(tags, ","))
 	}
@@ -224,15 +254,10 @@ func build(pkg string, tags []string) {
 		args = append(args, "-race")
 	}
 	args = append(args, pkg)
-	setBuildEnv()
-	runPrint("go", args...)
 
-	// Create an md5 checksum of the binary, to be included in the archive for
-	// automatic upgrades.
-	err := md5File(binary)
-	if err != nil {
-		log.Fatal(err)
-	}
+	os.Setenv("GOOS", goos)
+	os.Setenv("GOARCH", goarch)
+	runPrint("go", args...)
 }
 
 func buildTar() {
@@ -249,7 +274,6 @@ func buildTar() {
 		{src: "LICENSE", dst: name + "/LICENSE.txt"},
 		{src: "AUTHORS", dst: name + "/AUTHORS.txt"},
 		{src: "syncthing", dst: name + "/syncthing"},
-		{src: "syncthing.md5", dst: name + "/syncthing.md5"},
 	}
 
 	for _, file := range listFiles("etc") {
@@ -259,6 +283,9 @@ func buildTar() {
 		files = append(files, archiveFile{src: file, dst: name + "/" + filepath.Base(file)})
 	}
 
+	if goos == "darwin" {
+		macosCodesign("syncthing")
+	}
 	tarGz(filename, files)
 	log.Println(filename)
 }
@@ -277,7 +304,6 @@ func buildZip() {
 		{src: "LICENSE", dst: name + "/LICENSE.txt"},
 		{src: "AUTHORS", dst: name + "/AUTHORS.txt"},
 		{src: "syncthing.exe", dst: name + "/syncthing.exe"},
-		{src: "syncthing.exe.md5", dst: name + "/syncthing.exe.md5"},
 	}
 
 	for _, file := range listFiles("extra") {
@@ -320,6 +346,7 @@ func buildDeb() {
 		{src: "man/syncthing-security.7", dst: "deb/usr/share/man/man7/syncthing-security.7", perm: 0644},
 		{src: "man/syncthing-versioning.7", dst: "deb/usr/share/man/man7/syncthing-versioning.7", perm: 0644},
 		{src: "etc/linux-systemd/system/syncthing@.service", dst: "deb/lib/systemd/system/syncthing@.service", perm: 0644},
+		{src: "etc/linux-systemd/system/syncthing-resume.service", dst: "deb/lib/systemd/system/syncthing-resume.service", perm: 0644},
 		{src: "etc/linux-systemd/user/syncthing.service", dst: "deb/usr/lib/systemd/user/syncthing.service", perm: 0644},
 	}
 
@@ -333,33 +360,32 @@ func buildDeb() {
 		}
 	}
 
-	control := `Package: syncthing
-Architecture: {{arch}}
-Depends: libc6
-Version: {{version}}
-Maintainer: Syncthing Release Management <release@syncthing.net>
-Description: Open Source Continuous File Synchronization
-	Syncthing does bidirectional synchronization of files between two or
-	more computers.
-`
-	changelog := `syncthing ({{version}}); urgency=medium
-
-  * Packaging of {{version}}.
-
- -- Jakob Borg <jakob@nym.se>  {{date}}
-`
-
-	control = strings.Replace(control, "{{arch}}", debarch, -1)
-	control = strings.Replace(control, "{{version}}", version[1:], -1)
-	changelog = strings.Replace(changelog, "{{arch}}", debarch, -1)
-	changelog = strings.Replace(changelog, "{{version}}", version[1:], -1)
-	changelog = strings.Replace(changelog, "{{date}}", time.Now().Format(time.RFC1123), -1)
-
 	os.MkdirAll("deb/DEBIAN", 0755)
-	ioutil.WriteFile("deb/DEBIAN/control", []byte(control), 0644)
-	ioutil.WriteFile("deb/DEBIAN/compat", []byte("9\n"), 0644)
-	ioutil.WriteFile("deb/DEBIAN/changelog", []byte(changelog), 0644)
 
+	data := map[string]string{
+		"arch":    debarch,
+		"version": version[1:],
+		"date":    time.Now().Format(time.RFC1123),
+	}
+	for _, file := range listFiles("debian") {
+		tpl, err := template.New(filepath.Base(file)).ParseFiles(file)
+		if err != nil {
+			log.Fatal(err)
+		}
+		outFile := filepath.Join("deb/DEBIAN", filepath.Base(file))
+		out, err := os.Create(outFile)
+		if err != nil {
+			log.Fatal(err)
+		}
+		if err := tpl.Execute(out, data); err != nil {
+			log.Fatal(err)
+		}
+		if err := out.Close(); err != nil {
+			log.Fatal(err)
+		}
+		info, _ := os.Lstat(file)
+		os.Chmod(outFile, info.Mode())
+	}
 }
 
 func copyFile(src, dst string, perm os.FileMode) error {
@@ -393,59 +419,70 @@ func listFiles(dir string) []string {
 	return res
 }
 
-func setBuildEnv() {
-	os.Setenv("GOOS", goos)
-	os.Setenv("GOARCH", goarch)
-	wd, err := os.Getwd()
-	if err != nil {
-		log.Println("Warning: can't determine current dir:", err)
-		log.Println("Build might not work as expected")
-	}
-	os.Setenv("GOPATH", fmt.Sprintf("%s%c%s", filepath.Join(wd, "Godeps", "_workspace"), os.PathListSeparator, os.Getenv("GOPATH")))
-	log.Println("GOPATH=" + os.Getenv("GOPATH"))
-}
-
-func assets() {
-	setBuildEnv()
+func rebuildAssets() {
 	runPipe("lib/auto/gui.files.go", "go", "run", "script/genassets.go", "gui")
 }
 
+func lazyRebuildAssets() {
+	if shouldRebuildAssets() {
+		rebuildAssets()
+	}
+}
+
+func shouldRebuildAssets() bool {
+	info, err := os.Stat("lib/auto/gui.files.go")
+	if err != nil {
+		// If the file doesn't exist, we must rebuild it
+		return true
+	}
+
+	// Check if any of the files in gui/ are newer than the asset file. If
+	// so we should rebuild it.
+	currentBuild := info.ModTime()
+	assetsAreNewer := false
+	filepath.Walk("gui", func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+		if assetsAreNewer {
+			return nil
+		}
+		assetsAreNewer = info.ModTime().After(currentBuild)
+		return nil
+	})
+
+	return assetsAreNewer
+}
+
 func xdr() {
-	runPrint("go", "generate", "./lib/discover", "./lib/db")
+	runPrint("go", "generate", "./lib/discover", "./lib/db", "./lib/protocol", "./lib/relay/protocol")
 }
 
 func translate() {
-	os.Chdir("gui/assets/lang")
-	runPipe("lang-en-new.json", "go", "run", "../../../script/translate.go", "lang-en.json", "../../")
+	os.Chdir("gui/default/assets/lang")
+	runPipe("lang-en-new.json", "go", "run", "../../../../script/translate.go", "lang-en.json", "../../../")
 	os.Remove("lang-en.json")
 	err := os.Rename("lang-en-new.json", "lang-en.json")
 	if err != nil {
 		log.Fatal(err)
 	}
-	os.Chdir("../../..")
+	os.Chdir("../../../..")
 }
 
 func transifex() {
-	os.Chdir("gui/assets/lang")
-	runPrint("go", "run", "../../../script/transifexdl.go")
-	os.Chdir("../../..")
-	assets()
-}
-
-func deps() {
-	rmr("Godeps")
-	runPrint("godep", "save", "./cmd/...")
+	os.Chdir("gui/default/assets/lang")
+	runPrint("go", "run", "../../../../script/transifexdl.go")
 }
 
 func clean() {
-	rmr("bin", "Godeps/_workspace/pkg", "Godeps/_workspace/bin")
+	rmr("bin")
 	rmr(filepath.Join(os.Getenv("GOPATH"), fmt.Sprintf("pkg/%s_%s/github.com/syncthing", goos, goarch)))
 }
 
 func ldflags() string {
-	sep := ' '
-	if goVersion > 1.4 {
-		sep = '='
+	sep := '='
+	if goVersion > 0 && goVersion < 1.5 {
+		sep = ' '
 	}
 
 	b := new(bytes.Buffer)
@@ -454,7 +491,6 @@ func ldflags() string {
 	fmt.Fprintf(b, " -X main.BuildStamp%c%d", sep, buildStamp())
 	fmt.Fprintf(b, " -X main.BuildUser%c%s", sep, buildUser())
 	fmt.Fprintf(b, " -X main.BuildHost%c%s", sep, buildHost())
-	fmt.Fprintf(b, " -X main.BuildEnv%c%s", sep, buildEnvironment())
 	return b.String()
 }
 
@@ -498,12 +534,66 @@ func getVersion() string {
 	}
 	// ... then see if we have a Git tag.
 	if ver, err := getGitVersion(); err == nil {
+		if strings.Contains(ver, "-") {
+			// The version already contains a hash and stuff. See if we can
+			// find a current branch name to tack onto it as well.
+			return ver + getBranchSuffix()
+		}
 		return ver
 	}
 	// This seems to be a dev build.
 	return "unknown-dev"
 }
 
+func getBranchSuffix() string {
+	bs, err := runError("git", "branch", "-a", "--contains")
+	if err != nil {
+		return ""
+	}
+
+	branches := strings.Split(string(bs), "\n")
+	if len(branches) == 0 {
+		return ""
+	}
+
+	branch := ""
+	for i, candidate := range branches {
+		if strings.HasPrefix(candidate, "*") {
+			// This is the current branch. Select it!
+			branch = strings.TrimLeft(candidate, " \t*")
+			break
+		} else if i == 0 {
+			// Otherwise the first branch in the list will do.
+			branch = strings.TrimSpace(branch)
+		}
+	}
+
+	if branch == "" {
+		return ""
+	}
+
+	// The branch name may be on the form "remotes/origin/foo" from which we
+	// just want "foo".
+	parts := strings.Split(branch, "/")
+	if len(parts) == 0 || len(parts[len(parts)-1]) == 0 {
+		return ""
+	}
+
+	branch = parts[len(parts)-1]
+	if branch == "master" {
+		// master builds are the default.
+		return ""
+	}
+
+	validBranchRe := regexp.MustCompile(`^[a-zA-Z0-9_.-]+$`)
+	if !validBranchRe.MatchString(branch) {
+		// There's some odd stuff in the branch name. Better skip it.
+		return ""
+	}
+
+	return "-" + branch
+}
+
 func buildStamp() int64 {
 	bs, err := runError("git", "show", "-s", "--format=%ct")
 	if err != nil {
@@ -712,32 +802,6 @@ func zipFile(out string, files []archiveFile) {
 	}
 }
 
-func md5File(file string) error {
-	fd, err := os.Open(file)
-	if err != nil {
-		return err
-	}
-	defer fd.Close()
-
-	h := md5.New()
-	_, err = io.Copy(h, fd)
-	if err != nil {
-		return err
-	}
-
-	out, err := os.Create(file + ".md5")
-	if err != nil {
-		return err
-	}
-
-	_, err = fmt.Fprintf(out, "%x\n", h.Sum(nil))
-	if err != nil {
-		return err
-	}
-
-	return out.Close()
-}
-
 func vet(pkg string) {
 	bs, err := runError("go", "vet", pkg)
 	if err != nil && err.Error() == "exit status 3" || bytes.Contains(bs, []byte("no such tool \"vet\"")) {
@@ -775,3 +839,22 @@ func lint(pkg string) {
 		}
 	}
 }
+
+func macosCodesign(file string) {
+	if pass := os.Getenv("CODESIGN_KEYCHAIN_PASS"); pass != "" {
+		bs, err := runError("security", "unlock-keychain", "-p", pass)
+		if err != nil {
+			log.Println("Codesign: unlocking keychain failed:", string(bs))
+			return
+		}
+	}
+
+	if id := os.Getenv("CODESIGN_IDENTITY"); id != "" {
+		bs, err := runError("codesign", "-s", id, file)
+		if err != nil {
+			log.Println("Codesign: signing failed:", string(bs))
+			return
+		}
+		log.Println("Codesign: successfully signed", file)
+	}
+}

build.sh

@@ -27,10 +27,6 @@ case "${1:-default}" in
 		build "$@"
 		;;
 
-	deps)
-		build "$@"
-		;;
-
 	assets)
 		build "$@"
 		;;
@@ -63,8 +59,9 @@ case "${1:-default}" in
 		;;
 
 	prerelease)
+		go run script/authors.go
 		build transifex
-		git add -A gui/assets/ lib/auto/
+		git add -A gui/default/assets/ lib/auto/
 		pushd man ; ./refresh.sh ; popd
 		git add -A man
 		;;
@@ -74,27 +71,26 @@ case "${1:-default}" in
 		;;
 
 	all)
-		build -goos darwin -goarch amd64 tar
+		platforms=(
+			darwin-amd64 dragonfly-amd64 freebsd-amd64 linux-amd64 netbsd-amd64 openbsd-amd64 solaris-amd64 windows-amd64
+			freebsd-386 linux-386 netbsd-386 openbsd-386 windows-386
+			linux-arm linux-arm64 linux-ppc64 linux-ppc64le
+		)
 
-		build -goos dragonfly -goarch amd64 tar
+		for plat in "${platforms[@]}"; do
+			echo Building "$plat"
 
-		build -goos freebsd -goarch 386 tar
-		build -goos freebsd -goarch amd64 tar
+			goos="${plat%-*}"
+			goarch="${plat#*-}"
+			dist="tar"
 
-		build -goos linux -goarch 386 tar
-		build -goos linux -goarch amd64 tar
-		build -goos linux -goarch arm tar
+			if [[ $goos == "windows" ]]; then
+				dist="zip"
+			fi
 
-		build -goos netbsd -goarch 386 tar
-		build -goos netbsd -goarch amd64 tar
-
-		build -goos openbsd -goarch 386 tar
-		build -goos openbsd -goarch amd64 tar
-
-		build -goos solaris -goarch amd64 tar
-
-		build -goos windows -goarch 386 zip
-		build -goos windows -goarch amd64 zip
+			build -goos "$goos" -goarch "$goarch" "$dist"
+			echo
+		done
 		;;
 
 	test-cov)
@@ -106,12 +102,12 @@ case "${1:-default}" in
 		fail=0
 
 		# For every package in the repo
-		for dir in $(go list ./...) ; do
+		for dir in $(go list ./lib/... ./cmd/...) ; do
 			# run the tests
-			godep go test -coverprofile=profile.out $dir
+			GOPATH="$(pwd)/Godeps/_workspace:$GOPATH" go test -race -coverprofile=profile.out $dir
 			if [ -f profile.out ] ; then
 				# and if there was test output, append it to coverage.out
-				grep -v "mode: set" profile.out >> coverage.out
+				grep -v "mode: " profile.out >> coverage.out
 				rm profile.out
 			fi
 		done
@@ -126,6 +122,15 @@ case "${1:-default}" in
 		fi
 		;;
 
+	test-xunit)
+		ulimit -t 600 &>/dev/null || true
+		ulimit -d 512000 &>/dev/null || true
+		ulimit -m 512000 &>/dev/null || true
+
+		(GOPATH="$(pwd)/Godeps/_workspace:$GOPATH" go test -v -race ./lib/... ./cmd/... || true) > tests.out
+		go2xunit -output tests.xml -fail < tests.out
+		;;
+
 	docker-all)
 		img=${DOCKERIMG:-syncthing/build:latest}
 		docker run --rm -h syncthing-builder -u $(id -u) -t \

cmd/stbench/main.go

@@ -0,0 +1,143 @@
+// Copyright (C) 2016 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+// This doesn't build on Windows due to the Rusage stuff.
+
+// +build !windows
+
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+	"runtime"
+	"syscall"
+	"time"
+
+	"github.com/syncthing/syncthing/lib/rc"
+)
+
+var homeDir = "h1"
+var syncthingBin = "./bin/syncthing"
+var test = "scan"
+
+func main() {
+	flag.StringVar(&homeDir, "home", homeDir, "Home directory location")
+	flag.StringVar(&syncthingBin, "bin", syncthingBin, "Binary location")
+	flag.StringVar(&test, "test", test, "Test to run")
+	flag.Parse()
+
+	switch test {
+	case "scan":
+		// scan measures the resource usage required to perform the initial
+		// scan, without cleaning away the database first.
+		testScan()
+	}
+}
+
+// testScan starts a process and reports on the resource usage required to
+// perform the initial scan.
+func testScan() {
+	log.Println("Starting...")
+	p := rc.NewProcess("127.0.0.1:8081")
+	if err := p.Start(syncthingBin, "-home", homeDir, "-no-browser"); err != nil {
+		log.Println(err)
+		return
+	}
+	defer p.Stop()
+
+	wallTime := awaitScanComplete(p)
+
+	report(p, wallTime)
+}
+
+// awaitScanComplete waits for a folder to transition idle->scanning and
+// then scanning->idle and returns the time taken for the scan.
+func awaitScanComplete(p *rc.Process) time.Duration {
+	log.Println("Awaiting scan completion...")
+	var t0, t1 time.Time
+	lastEvent := 0
+loop:
+	for {
+		evs, err := p.Events(lastEvent)
+		if err != nil {
+			continue
+		}
+
+		for _, ev := range evs {
+			if ev.Type == "StateChanged" {
+				data := ev.Data.(map[string]interface{})
+				log.Println(ev)
+
+				if data["to"].(string) == "scanning" {
+					t0 = ev.Time
+					continue
+				}
+
+				if !t0.IsZero() && data["to"].(string) == "idle" {
+					t1 = ev.Time
+					break loop
+				}
+			}
+			lastEvent = ev.ID
+		}
+
+		time.Sleep(250 * time.Millisecond)
+	}
+
+	return t1.Sub(t0)
+}
+
+// report stops the given process and reports on it's resource usage in two
+// ways: human readable to stderr, and CSV to stdout.
+func report(p *rc.Process, wallTime time.Duration) {
+	sv, err := p.SystemVersion()
+	if err != nil {
+		log.Println(err)
+		return
+	}
+
+	ss, err := p.SystemStatus()
+	if err != nil {
+		log.Println(err)
+		return
+	}
+
+	proc, err := p.Stop()
+	if err != nil {
+		return
+	}
+
+	rusage, ok := proc.SysUsage().(*syscall.Rusage)
+	if !ok {
+		return
+	}
+
+	log.Println("Version:", sv.Version)
+	log.Println("Alloc:", ss.Alloc/1024, "KiB")
+	log.Println("Sys:", ss.Sys/1024, "KiB")
+	log.Println("Goroutines:", ss.Goroutines)
+	log.Println("Wall time:", wallTime)
+	log.Println("Utime:", time.Duration(rusage.Utime.Nano()))
+	log.Println("Stime:", time.Duration(rusage.Stime.Nano()))
+	if runtime.GOOS == "darwin" {
+		// Darwin reports in bytes, Linux seems to report in KiB even
+		// though the manpage says otherwise.
+		rusage.Maxrss /= 1024
+	}
+	log.Println("MaxRSS:", rusage.Maxrss, "KiB")
+
+	fmt.Printf("%s,%d,%d,%d,%.02f,%.02f,%.02f,%d\n",
+		sv.Version,
+		ss.Alloc/1024,
+		ss.Sys/1024,
+		ss.Goroutines,
+		wallTime.Seconds(),
+		time.Duration(rusage.Utime.Nano()).Seconds(),
+		time.Duration(rusage.Stime.Nano()).Seconds(),
+		rusage.Maxrss)
+}

cmd/stfileinfo/main.go

@@ -12,7 +12,7 @@ import (
 	"os"
 	"path/filepath"
 
-	"github.com/syncthing/protocol"
+	"github.com/syncthing/syncthing/lib/protocol"
 	"github.com/syncthing/syncthing/lib/scanner"
 )
 
@@ -68,7 +68,7 @@ func main() {
 		if *standardBlocks || blockSize < protocol.BlockSize {
 			blockSize = protocol.BlockSize
 		}
-		bs, err := scanner.Blocks(fd, blockSize, fi.Size())
+		bs, err := scanner.Blocks(fd, blockSize, fi.Size(), nil)
 		if err != nil {
 			log.Fatal(err)
 		}

cmd/stfinddevice/main.go

@@ -7,37 +7,105 @@
 package main
 
 import (
+	"crypto/tls"
+	"errors"
 	"flag"
-	"log"
+	"fmt"
+	"net/url"
 	"os"
+	"time"
 
-	"github.com/syncthing/protocol"
+	"github.com/syncthing/syncthing/lib/config"
 	"github.com/syncthing/syncthing/lib/discover"
+	"github.com/syncthing/syncthing/lib/protocol"
 )
 
-func main() {
-	log.SetFlags(0)
-	log.SetOutput(os.Stdout)
+var timeout = 5 * time.Second
 
+func main() {
 	var server string
 
-	flag.StringVar(&server, "server", "udp4://announce.syncthing.net:22026", "Announce server")
+	flag.StringVar(&server, "server", "", "Announce server (blank for default set)")
+	flag.DurationVar(&timeout, "timeout", timeout, "Query timeout")
+	flag.Usage = usage
 	flag.Parse()
 
-	if len(flag.Args()) != 1 || server == "" {
-		log.Printf("Usage: %s [-server=\"udp4://announce.syncthing.net:22026\"] <device>", os.Args[0])
+	if flag.NArg() != 1 {
+		flag.Usage()
 		os.Exit(64)
 	}
 
 	id, err := protocol.DeviceIDFromString(flag.Args()[0])
 	if err != nil {
-		log.Println(err)
+		fmt.Println(err)
 		os.Exit(1)
 	}
 
-	discoverer := discover.NewDiscoverer(protocol.LocalDeviceID, nil)
-	discoverer.StartGlobal([]string{server}, 1)
-	for _, addr := range discoverer.Lookup(id) {
-		log.Println(addr)
+	if server != "" {
+		checkServers(id, server)
+	} else {
+		checkServers(id, config.DefaultDiscoveryServers...)
 	}
 }
+
+type checkResult struct {
+	server string
+	direct []string
+	relays []discover.Relay
+	error
+}
+
+func checkServers(deviceID protocol.DeviceID, servers ...string) {
+	t0 := time.Now()
+	resc := make(chan checkResult)
+	for _, srv := range servers {
+		srv := srv
+		go func() {
+			res := checkServer(deviceID, srv)
+			res.server = srv
+			resc <- res
+		}()
+	}
+
+	for _ = range servers {
+		res := <-resc
+
+		u, _ := url.Parse(res.server)
+		fmt.Printf("%s (%v):\n", u.Host, time.Since(t0))
+
+		if res.error != nil {
+			fmt.Println("  " + res.error.Error())
+		}
+		for _, addr := range res.direct {
+			fmt.Println("  address:", addr)
+		}
+		for _, rel := range res.relays {
+			fmt.Printf("  relay: %s (%d ms)\n", rel.URL, rel.Latency)
+		}
+	}
+}
+
+func checkServer(deviceID protocol.DeviceID, server string) checkResult {
+	disco, err := discover.NewGlobal(server, tls.Certificate{}, nil, nil)
+	if err != nil {
+		return checkResult{error: err}
+	}
+
+	res := make(chan checkResult, 1)
+
+	time.AfterFunc(timeout, func() {
+		res <- checkResult{error: errors.New("timeout")}
+	})
+
+	go func() {
+		direct, relays, err := disco.Lookup(deviceID)
+		res <- checkResult{direct: direct, relays: relays, error: err}
+	}()
+
+	return <-res
+}
+
+func usage() {
+	fmt.Printf("Usage:\n\t%s [options] <device ID>\n\nOptions:\n", os.Args[0])
+	flag.PrintDefaults()
+}

cmd/stgenfiles/main.go

@@ -0,0 +1,124 @@
+// Copyright (C) 2016 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package main
+
+import (
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"math/rand"
+	"os"
+	"path/filepath"
+	"time"
+)
+
+func main() {
+	dir := flag.String("dir", "~/files", "Directory to generate into")
+	files := flag.Int("files", 1000, "Number of files to create")
+	maxExp := flag.Int("maxexp", 20, "Max size exponent")
+	src := flag.String("src", "/dev/urandom", "Source of file data")
+	flag.Parse()
+	if err := generateFiles(*dir, *files, *maxExp, *src); err != nil {
+		log.Println(err)
+	}
+}
+
+func generateFiles(dir string, files, maxexp int, srcname string) error {
+	fd, err := os.Open(srcname)
+	if err != nil {
+		return err
+	}
+
+	for i := 0; i < files; i++ {
+		n := randomName()
+
+		if rand.Float64() < 0.05 {
+			// Some files and directories are dotfiles
+			n = "." + n
+		}
+
+		p0 := filepath.Join(dir, string(n[0]), n[0:2])
+		err = os.MkdirAll(p0, 0755)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		p1 := filepath.Join(p0, n)
+
+		s := int64(1 << uint(rand.Intn(maxexp)))
+		a := int64(128 * 1024)
+		if a > s {
+			a = s
+		}
+		s += rand.Int63n(a)
+
+		if err := generateOneFile(fd, p1, s); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func generateOneFile(fd io.ReadSeeker, p1 string, s int64) error {
+	src := io.LimitReader(&inifiteReader{fd}, int64(s))
+	dst, err := os.Create(p1)
+	if err != nil {
+		return err
+	}
+
+	_, err = io.Copy(dst, src)
+	if err != nil {
+		return err
+	}
+
+	err = dst.Close()
+	if err != nil {
+		return err
+	}
+
+	_ = os.Chmod(p1, os.FileMode(rand.Intn(0777)|0400))
+
+	t := time.Now().Add(-time.Duration(rand.Intn(30*86400)) * time.Second)
+	err = os.Chtimes(p1, t, t)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func randomName() string {
+	var b [16]byte
+	readRand(b[:])
+	return fmt.Sprintf("%x", b[:])
+}
+
+func readRand(bs []byte) (int, error) {
+	var r uint32
+	for i := range bs {
+		if i%4 == 0 {
+			r = uint32(rand.Int63())
+		}
+		bs[i] = byte(r >> uint((i%4)*8))
+	}
+	return len(bs), nil
+}
+
+type inifiteReader struct {
+	rd io.ReadSeeker
+}
+
+func (i *inifiteReader) Read(bs []byte) (int, error) {
+	n, err := i.rd.Read(bs)
+	if err == io.EOF {
+		err = nil
+		i.rd.Seek(0, 0)
+	}
+	return n, err
+}

cmd/stindex/dump.go

@@ -0,0 +1,63 @@
+// Copyright (C) 2015 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package main
+
+import (
+	"encoding/binary"
+	"fmt"
+	"log"
+
+	"github.com/syncthing/syncthing/lib/db"
+	"github.com/syncthing/syncthing/lib/protocol"
+	"github.com/syndtr/goleveldb/leveldb"
+)
+
+func dump(ldb *leveldb.DB) {
+	it := ldb.NewIterator(nil, nil)
+	var dev protocol.DeviceID
+	for it.Next() {
+		key := it.Key()
+		switch key[0] {
+		case db.KeyTypeDevice:
+			folder := nulString(key[1 : 1+64])
+			devBytes := key[1+64 : 1+64+32]
+			name := nulString(key[1+64+32:])
+			copy(dev[:], devBytes)
+			fmt.Printf("[device] F:%q N:%q D:%v\n", folder, name, dev)
+
+			var f protocol.FileInfo
+			err := f.UnmarshalXDR(it.Value())
+			if err != nil {
+				log.Fatal(err)
+			}
+			fmt.Printf("  N:%q\n  F:%#o\n  M:%d\n  V:%v\n  S:%d\n  B:%d\n", f.Name, f.Flags, f.Modified, f.Version, f.Size(), len(f.Blocks))
+
+		case db.KeyTypeGlobal:
+			folder := nulString(key[1 : 1+64])
+			name := nulString(key[1+64:])
+			fmt.Printf("[global] F:%q N:%q V:%x\n", folder, name, it.Value())
+
+		case db.KeyTypeBlock:
+			folder := nulString(key[1 : 1+64])
+			hash := key[1+64 : 1+64+32]
+			name := nulString(key[1+64+32:])
+			fmt.Printf("[block] F:%q H:%x N:%q I:%d\n", folder, hash, name, binary.BigEndian.Uint32(it.Value()))
+
+		case db.KeyTypeDeviceStatistic:
+			fmt.Printf("[dstat]\n  %x\n  %x\n", it.Key(), it.Value())
+
+		case db.KeyTypeFolderStatistic:
+			fmt.Printf("[fstat]\n  %x\n  %x\n", it.Key(), it.Value())
+
+		case db.KeyTypeVirtualMtime:
+			fmt.Printf("[mtime]\n  %x\n  %x\n", it.Key(), it.Value())
+
+		default:
+			fmt.Printf("[???]\n  %x\n  %x\n", it.Key(), it.Value())
+		}
+	}
+}

cmd/stindex/dumpsize.go

@@ -0,0 +1,90 @@
+// Copyright (C) 2015 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package main
+
+import (
+	"container/heap"
+	"fmt"
+
+	"github.com/syncthing/syncthing/lib/db"
+	"github.com/syncthing/syncthing/lib/protocol"
+	"github.com/syndtr/goleveldb/leveldb"
+)
+
+// An IntHeap is a min-heap of ints.
+type SizedElement struct {
+	key  string
+	size int
+}
+
+type ElementHeap []SizedElement
+
+func (h ElementHeap) Len() int           { return len(h) }
+func (h ElementHeap) Less(i, j int) bool { return h[i].size > h[j].size }
+func (h ElementHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
+
+func (h *ElementHeap) Push(x interface{}) {
+	*h = append(*h, x.(SizedElement))
+}
+
+func (h *ElementHeap) Pop() interface{} {
+	old := *h
+	n := len(old)
+	x := old[n-1]
+	*h = old[0 : n-1]
+	return x
+}
+
+func dumpsize(ldb *leveldb.DB) {
+	h := &ElementHeap{}
+	heap.Init(h)
+
+	it := ldb.NewIterator(nil, nil)
+	var dev protocol.DeviceID
+	var ele SizedElement
+	for it.Next() {
+		key := it.Key()
+		switch key[0] {
+		case db.KeyTypeDevice:
+			folder := nulString(key[1 : 1+64])
+			devBytes := key[1+64 : 1+64+32]
+			name := nulString(key[1+64+32:])
+			copy(dev[:], devBytes)
+			ele.key = fmt.Sprintf("DEVICE:%s:%s:%s", dev, folder, name)
+
+		case db.KeyTypeGlobal:
+			folder := nulString(key[1 : 1+64])
+			name := nulString(key[1+64:])
+			ele.key = fmt.Sprintf("GLOBAL:%s:%s", folder, name)
+
+		case db.KeyTypeBlock:
+			folder := nulString(key[1 : 1+64])
+			hash := key[1+64 : 1+64+32]
+			name := nulString(key[1+64+32:])
+			ele.key = fmt.Sprintf("BLOCK:%s:%x:%s", folder, hash, name)
+
+		case db.KeyTypeDeviceStatistic:
+			ele.key = fmt.Sprintf("DEVICESTATS:%s", key[1:])
+
+		case db.KeyTypeFolderStatistic:
+			ele.key = fmt.Sprintf("FOLDERSTATS:%s", key[1:])
+
+		case db.KeyTypeVirtualMtime:
+			ele.key = fmt.Sprintf("MTIME:%s", key[1:])
+
+		default:
+			ele.key = fmt.Sprintf("UNKNOWN:%x", key)
+		}
+		ele.size = len(it.Value())
+		heap.Push(h, ele)
+	}
+
+	for h.Len() > 0 {
+		ele = heap.Pop(h).(SizedElement)
+		fmt.Println(ele.key, ele.size)
+	}
+}

cmd/stindex/main.go

@@ -7,25 +7,33 @@
 package main
 
 import (
-	"encoding/binary"
 	"flag"
 	"fmt"
 	"log"
 	"os"
+	"path/filepath"
 
-	"github.com/syncthing/protocol"
-	"github.com/syncthing/syncthing/lib/db"
 	"github.com/syndtr/goleveldb/leveldb"
 	"github.com/syndtr/goleveldb/leveldb/opt"
 )
 
 func main() {
+	var mode string
 	log.SetFlags(0)
 	log.SetOutput(os.Stdout)
 
+	flag.StringVar(&mode, "mode", "dump", "Mode of operation: dump, dumpsize")
+
 	flag.Parse()
 
-	ldb, err := leveldb.OpenFile(flag.Arg(0), &opt.Options{
+	path := flag.Arg(0)
+	if path == "" {
+		path = filepath.Join(defaultConfigDir(), "index-v0.11.0.db")
+	}
+
+	fmt.Println("Path:", path)
+
+	ldb, err := leveldb.OpenFile(path, &opt.Options{
 		ErrorIfMissing:         true,
 		Strict:                 opt.StrictAll,
 		OpenFilesCacheCapacity: 100,
@@ -34,53 +42,11 @@ func main() {
 		log.Fatal(err)
 	}
 
-	it := ldb.NewIterator(nil, nil)
-	var dev protocol.DeviceID
-	for it.Next() {
-		key := it.Key()
-		switch key[0] {
-		case db.KeyTypeDevice:
-			folder := nulString(key[1 : 1+64])
-			devBytes := key[1+64 : 1+64+32]
-			name := nulString(key[1+64+32:])
-			copy(dev[:], devBytes)
-			fmt.Printf("[device] F:%q N:%q D:%v\n", folder, name, dev)
-
-			var f protocol.FileInfo
-			err := f.UnmarshalXDR(it.Value())
-			if err != nil {
-				log.Fatal(err)
-			}
-			fmt.Printf("  N:%q\n  F:%#o\n  M:%d\n  V:%v\n  S:%d\n  B:%d\n", f.Name, f.Flags, f.Modified, f.Version, f.Size(), len(f.Blocks))
-
-		case db.KeyTypeGlobal:
-			folder := nulString(key[1 : 1+64])
-			name := nulString(key[1+64:])
-			fmt.Printf("[global] F:%q N:%q V:%x\n", folder, name, it.Value())
-
-		case db.KeyTypeBlock:
-			folder := nulString(key[1 : 1+64])
-			hash := key[1+64 : 1+64+32]
-			name := nulString(key[1+64+32:])
-			fmt.Printf("[block] F:%q H:%x N:%q I:%d\n", folder, hash, name, binary.BigEndian.Uint32(it.Value()))
-
-		case db.KeyTypeDeviceStatistic:
-			fmt.Printf("[dstat]\n  %x\n  %x\n", it.Key(), it.Value())
-
-		case db.KeyTypeFolderStatistic:
-			fmt.Printf("[fstat]\n  %x\n  %x\n", it.Key(), it.Value())
-
-		default:
-			fmt.Printf("[???]\n  %x\n  %x\n", it.Key(), it.Value())
-		}
+	if mode == "dump" {
+		dump(ldb)
+	} else if mode == "dumpsize" {
+		dumpsize(ldb)
+	} else {
+		fmt.Println("Unknown mode")
 	}
 }
-
-func nulString(bs []byte) string {
-	for i := range bs {
-		if bs[i] == 0 {
-			return string(bs[:i])
-		}
-	}
-	return string(bs)
-}

cmd/stindex/util.go

@@ -0,0 +1,52 @@
+// Copyright (C) 2015 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package main
+
+import (
+	"log"
+	"os"
+	"path/filepath"
+	"runtime"
+
+	"github.com/syncthing/syncthing/lib/osutil"
+)
+
+func nulString(bs []byte) string {
+	for i := range bs {
+		if bs[i] == 0 {
+			return string(bs[:i])
+		}
+	}
+	return string(bs)
+}
+
+func defaultConfigDir() string {
+	switch runtime.GOOS {
+	case "windows":
+		if p := os.Getenv("LocalAppData"); p != "" {
+			return filepath.Join(p, "Syncthing")
+		}
+		return filepath.Join(os.Getenv("AppData"), "Syncthing")
+
+	case "darwin":
+		dir, err := osutil.ExpandTilde("~/Library/Application Support/Syncthing")
+		if err != nil {
+			log.Fatal(err)
+		}
+		return dir
+
+	default:
+		if xdgCfg := os.Getenv("XDG_CONFIG_HOME"); xdgCfg != "" {
+			return filepath.Join(xdgCfg, "syncthing")
+		}
+		dir, err := osutil.ExpandTilde("~/.config/syncthing")
+		if err != nil {
+			log.Fatal(err)
+		}
+		return dir
+	}
+}

cmd/stsigtool/main.go

@@ -0,0 +1,115 @@
+// Copyright (C) 2015 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package main
+
+import (
+	"flag"
+	"io/ioutil"
+	"log"
+	"os"
+
+	"github.com/syncthing/syncthing/lib/signature"
+	"github.com/syncthing/syncthing/lib/upgrade"
+)
+
+func main() {
+	log.SetFlags(0)
+	log.SetOutput(os.Stdout)
+
+	flag.Parse()
+
+	if flag.NArg() < 1 {
+		log.Println(`Usage:
+	stsigtool <command>
+
+Where command is one of:
+
+	gen
+		- generate a new key pair
+
+	sign <privkeyfile> <datafile>
+		- sign a file
+
+	verify <signaturefile> <datafile>
+		- verify a signature, using the built in public key
+
+	verify <signaturefile> <datafile> <pubkeyfile>
+		- verify a signature, using the specified public key file
+`)
+	}
+
+	switch flag.Arg(0) {
+	case "gen":
+		gen()
+	case "sign":
+		sign(flag.Arg(1), flag.Arg(2))
+	case "verify":
+		if flag.NArg() == 4 {
+			verifyWithFile(flag.Arg(1), flag.Arg(2), flag.Arg(3))
+		} else {
+			verifyWithKey(flag.Arg(1), flag.Arg(2), upgrade.SigningKey)
+		}
+	}
+}
+
+func gen() {
+	priv, pub, err := signature.GenerateKeys()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	os.Stdout.Write(priv)
+	os.Stdout.Write(pub)
+}
+
+func sign(keyname, dataname string) {
+	privkey, err := ioutil.ReadFile(keyname)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	fd, err := os.Open(dataname)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer fd.Close()
+
+	sig, err := signature.Sign(privkey, fd)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	os.Stdout.Write(sig)
+}
+
+func verifyWithFile(signame, dataname, keyname string) {
+	pubkey, err := ioutil.ReadFile(keyname)
+	if err != nil {
+		log.Fatal(err)
+	}
+	verifyWithKey(signame, dataname, pubkey)
+}
+
+func verifyWithKey(signame, dataname string, pubkey []byte) {
+	sig, err := ioutil.ReadFile(signame)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	fd, err := os.Open(dataname)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer fd.Close()
+
+	err = signature.Verify(pubkey, sig, fd)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	log.Println("correct signature")
+}

cmd/syncthing/auditservice.go

@@ -13,17 +13,17 @@ import (
 	"github.com/syncthing/syncthing/lib/events"
 )
 
-// The auditSvc subscribes to events and writes these in JSON format, one
+// The auditService subscribes to events and writes these in JSON format, one
 // event per line, to the specified writer.
-type auditSvc struct {
+type auditService struct {
 	w       io.Writer     // audit destination
 	stop    chan struct{} // signals time to stop
 	started chan struct{} // signals startup complete
 	stopped chan struct{} // signals stop complete
 }
 
-func newAuditSvc(w io.Writer) *auditSvc {
-	return &auditSvc{
+func newAuditService(w io.Writer) *auditService {
+	return &auditService{
 		w:       w,
 		stop:    make(chan struct{}),
 		started: make(chan struct{}),
@@ -32,7 +32,7 @@ func newAuditSvc(w io.Writer) *auditSvc {
 }
 
 // Serve runs the audit service.
-func (s *auditSvc) Serve() {
+func (s *auditService) Serve() {
 	defer close(s.stopped)
 	sub := events.Default.Subscribe(events.AllEvents)
 	defer events.Default.Unsubscribe(sub)
@@ -52,18 +52,18 @@ func (s *auditSvc) Serve() {
 }
 
 // Stop stops the audit service.
-func (s *auditSvc) Stop() {
+func (s *auditService) Stop() {
 	close(s.stop)
 }
 
 // WaitForStart returns once the audit service is ready to receive events, or
 // immediately if it's already running.
-func (s *auditSvc) WaitForStart() {
+func (s *auditService) WaitForStart() {
 	<-s.started
 }
 
 // WaitForStop returns once the audit service has stopped.
 // (Needed by the tests.)
-func (s *auditSvc) WaitForStop() {
+func (s *auditService) WaitForStop() {
 	<-s.stopped
 }

cmd/syncthing/auditservice_test.go

@@ -17,13 +17,13 @@ import (
 
 func TestAuditService(t *testing.T) {
 	buf := new(bytes.Buffer)
-	svc := newAuditSvc(buf)
+	service := newAuditService(buf)
 
 	// Event sent before start, will not be logged
 	events.Default.Log(events.Ping, "the first event")
 
-	go svc.Serve()
-	svc.WaitForStart()
+	go service.Serve()
+	service.WaitForStart()
 
 	// Event that should end up in the audit log
 	events.Default.Log(events.Ping, "the second event")
@@ -31,8 +31,8 @@ func TestAuditService(t *testing.T) {
 	// We need to give the events time to arrive, since the channels are buffered etc.
 	time.Sleep(10 * time.Millisecond)
 
-	svc.Stop()
-	svc.WaitForStop()
+	service.Stop()
+	service.WaitForStop()
 
 	// This event should not be logged, since we have stopped.
 	events.Default.Log(events.Ping, "the third event")

cmd/syncthing/connections.go

@@ -1,372 +0,0 @@
-// Copyright (C) 2015 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"crypto/tls"
-	"fmt"
-	"io"
-	"net"
-	"strings"
-	"time"
-
-	"github.com/syncthing/protocol"
-	"github.com/syncthing/syncthing/lib/config"
-	"github.com/syncthing/syncthing/lib/events"
-	"github.com/syncthing/syncthing/lib/model"
-	"github.com/thejerf/suture"
-)
-
-// The connection service listens on TLS and dials configured unconnected
-// devices. Successful connections are handed to the model.
-type connectionSvc struct {
-	*suture.Supervisor
-	cfg    *config.Wrapper
-	myID   protocol.DeviceID
-	model  *model.Model
-	tlsCfg *tls.Config
-	conns  chan *tls.Conn
-}
-
-func newConnectionSvc(cfg *config.Wrapper, myID protocol.DeviceID, model *model.Model, tlsCfg *tls.Config) *connectionSvc {
-	svc := &connectionSvc{
-		Supervisor: suture.NewSimple("connectionSvc"),
-		cfg:        cfg,
-		myID:       myID,
-		model:      model,
-		tlsCfg:     tlsCfg,
-		conns:      make(chan *tls.Conn),
-	}
-
-	// There are several moving parts here; one routine per listening address
-	// to handle incoming connections, one routine to periodically attempt
-	// outgoing connections, and lastly one routine to the the common handling
-	// regardless of whether the connection was incoming or outgoing. It ends
-	// up as in the diagram below. We embed a Supervisor to manage the
-	// routines (i.e. log and restart if they crash or exit, etc).
-	//
-	//                +-----------------+
-	//    Incoming    | +---------------+-+      +-----------------+
-	//   Connections  | |                 |      |                 |   Outgoing
-	// -------------->| |   svc.listen    |      |                 |  Connections
-	//                | |  (1 per listen  |      |   svc.connect   |-------------->
-	//                | |    address)     |      |                 |
-	//                +-+                 |      |                 |
-	//                  +-----------------+      +-----------------+
-	//                           v                        v
-	//                           |                        |
-	//                           |                        |
-	//                           +------------+-----------+
-	//                                        |
-	//                                        | svc.conns
-	//                                        v
-	//                               +-----------------+
-	//                               |                 |
-	//                               |                 |
-	//                               |   svc.handle    |------> model.AddConnection()
-	//                               |                 |
-	//                               |                 |
-	//                               +-----------------+
-	//
-	// TODO: Clean shutdown, and/or handling config changes on the fly. We
-	// partly do this now - new devices and addresses will be picked up, but
-	// not new listen addresses and we don't support disconnecting devices
-	// that are removed and so on...
-
-	svc.Add(serviceFunc(svc.connect))
-	for _, addr := range svc.cfg.Options().ListenAddress {
-		addr := addr
-		listener := serviceFunc(func() {
-			svc.listen(addr)
-		})
-		svc.Add(listener)
-	}
-	svc.Add(serviceFunc(svc.handle))
-
-	return svc
-}
-
-func (s *connectionSvc) handle() {
-next:
-	for conn := range s.conns {
-		cs := conn.ConnectionState()
-
-		// We should have negotiated the next level protocol "bep/1.0" as part
-		// of the TLS handshake. Unfortunately this can't be a hard error,
-		// because there are implementations out there that don't support
-		// protocol negotiation (iOS for one...).
-		if !cs.NegotiatedProtocolIsMutual || cs.NegotiatedProtocol != bepProtocolName {
-			l.Infof("Peer %s did not negotiate bep/1.0", conn.RemoteAddr())
-		}
-
-		// We should have received exactly one certificate from the other
-		// side. If we didn't, they don't have a device ID and we drop the
-		// connection.
-		certs := cs.PeerCertificates
-		if cl := len(certs); cl != 1 {
-			l.Infof("Got peer certificate list of length %d != 1 from %s; protocol error", cl, conn.RemoteAddr())
-			conn.Close()
-			continue
-		}
-		remoteCert := certs[0]
-		remoteID := protocol.NewDeviceID(remoteCert.Raw)
-
-		// The device ID should not be that of ourselves. It can happen
-		// though, especially in the presence of NAT hairpinning, multiple
-		// clients between the same NAT gateway, and global discovery.
-		if remoteID == myID {
-			l.Infof("Connected to myself (%s) - should not happen", remoteID)
-			conn.Close()
-			continue
-		}
-
-		// We should not already be connected to the other party. TODO: This
-		// could use some better handling. If the old connection is dead but
-		// hasn't timed out yet we may want to drop *that* connection and keep
-		// this one. But in case we are two devices connecting to each other
-		// in parallel we don't want to do that or we end up with no
-		// connections still established...
-		if s.model.ConnectedTo(remoteID) {
-			l.Infof("Connected to already connected device (%s)", remoteID)
-			conn.Close()
-			continue
-		}
-
-		for deviceID, deviceCfg := range s.cfg.Devices() {
-			if deviceID == remoteID {
-				// Verify the name on the certificate. By default we set it to
-				// "syncthing" when generating, but the user may have replaced
-				// the certificate and used another name.
-				certName := deviceCfg.CertName
-				if certName == "" {
-					certName = tlsDefaultCommonName
-				}
-				err := remoteCert.VerifyHostname(certName)
-				if err != nil {
-					// Incorrect certificate name is something the user most
-					// likely wants to know about, since it's an advanced
-					// config. Warn instead of Info.
-					l.Warnf("Bad certificate from %s (%v): %v", remoteID, conn.RemoteAddr(), err)
-					conn.Close()
-					continue next
-				}
-
-				// If rate limiting is set, and based on the address we should
-				// limit the connection, then we wrap it in a limiter.
-
-				limit := s.shouldLimit(conn.RemoteAddr())
-
-				wr := io.Writer(conn)
-				if limit && writeRateLimit != nil {
-					wr = &limitedWriter{conn, writeRateLimit}
-				}
-
-				rd := io.Reader(conn)
-				if limit && readRateLimit != nil {
-					rd = &limitedReader{conn, readRateLimit}
-				}
-
-				name := fmt.Sprintf("%s-%s", conn.LocalAddr(), conn.RemoteAddr())
-				protoConn := protocol.NewConnection(remoteID, rd, wr, s.model, name, deviceCfg.Compression)
-
-				l.Infof("Established secure connection to %s at %s", remoteID, name)
-				if debugNet {
-					l.Debugf("cipher suite: %04X in lan: %t", conn.ConnectionState().CipherSuite, !limit)
-				}
-
-				s.model.AddConnection(conn, protoConn)
-				continue next
-			}
-		}
-
-		if !s.cfg.IgnoredDevice(remoteID) {
-			events.Default.Log(events.DeviceRejected, map[string]string{
-				"device":  remoteID.String(),
-				"address": conn.RemoteAddr().String(),
-			})
-			l.Infof("Connection from %s with unknown device ID %s", conn.RemoteAddr(), remoteID)
-		} else {
-			l.Infof("Connection from %s with ignored device ID %s", conn.RemoteAddr(), remoteID)
-		}
-
-		conn.Close()
-	}
-}
-
-func (s *connectionSvc) listen(addr string) {
-	if debugNet {
-		l.Debugln("listening on", addr)
-	}
-
-	tcaddr, err := net.ResolveTCPAddr("tcp", addr)
-	if err != nil {
-		l.Fatalln("listen (BEP):", err)
-	}
-	listener, err := net.ListenTCP("tcp", tcaddr)
-	if err != nil {
-		l.Fatalln("listen (BEP):", err)
-	}
-
-	for {
-		conn, err := listener.Accept()
-		if err != nil {
-			l.Warnln("Accepting connection:", err)
-			continue
-		}
-
-		if debugNet {
-			l.Debugln("connect from", conn.RemoteAddr())
-		}
-
-		tcpConn := conn.(*net.TCPConn)
-		s.setTCPOptions(tcpConn)
-
-		tc := tls.Server(conn, s.tlsCfg)
-		err = tc.Handshake()
-		if err != nil {
-			l.Infoln("TLS handshake:", err)
-			tc.Close()
-			continue
-		}
-
-		s.conns <- tc
-	}
-}
-
-func (s *connectionSvc) connect() {
-	delay := time.Second
-	for {
-	nextDevice:
-		for deviceID, deviceCfg := range s.cfg.Devices() {
-			if deviceID == myID {
-				continue
-			}
-
-			if s.model.ConnectedTo(deviceID) {
-				continue
-			}
-
-			var addrs []string
-			for _, addr := range deviceCfg.Addresses {
-				if addr == "dynamic" {
-					if discoverer != nil {
-						t := discoverer.Lookup(deviceID)
-						if len(t) == 0 {
-							continue
-						}
-						addrs = append(addrs, t...)
-					}
-				} else {
-					addrs = append(addrs, addr)
-				}
-			}
-
-			for _, addr := range addrs {
-				host, port, err := net.SplitHostPort(addr)
-				if err != nil && strings.HasPrefix(err.Error(), "missing port") {
-					// addr is on the form "1.2.3.4"
-					addr = net.JoinHostPort(addr, "22000")
-				} else if err == nil && port == "" {
-					// addr is on the form "1.2.3.4:"
-					addr = net.JoinHostPort(host, "22000")
-				}
-				if debugNet {
-					l.Debugln("dial", deviceCfg.DeviceID, addr)
-				}
-
-				raddr, err := net.ResolveTCPAddr("tcp", addr)
-				if err != nil {
-					if debugNet {
-						l.Debugln(err)
-					}
-					continue
-				}
-
-				conn, err := net.DialTCP("tcp", nil, raddr)
-				if err != nil {
-					if debugNet {
-						l.Debugln(err)
-					}
-					continue
-				}
-
-				s.setTCPOptions(conn)
-
-				tc := tls.Client(conn, s.tlsCfg)
-				err = tc.Handshake()
-				if err != nil {
-					l.Infoln("TLS handshake:", err)
-					tc.Close()
-					continue
-				}
-
-				s.conns <- tc
-				continue nextDevice
-			}
-		}
-
-		time.Sleep(delay)
-		delay *= 2
-		if maxD := time.Duration(s.cfg.Options().ReconnectIntervalS) * time.Second; delay > maxD {
-			delay = maxD
-		}
-	}
-}
-
-func (*connectionSvc) setTCPOptions(conn *net.TCPConn) {
-	var err error
-	if err = conn.SetLinger(0); err != nil {
-		l.Infoln(err)
-	}
-	if err = conn.SetNoDelay(false); err != nil {
-		l.Infoln(err)
-	}
-	if err = conn.SetKeepAlivePeriod(60 * time.Second); err != nil {
-		l.Infoln(err)
-	}
-	if err = conn.SetKeepAlive(true); err != nil {
-		l.Infoln(err)
-	}
-}
-
-func (s *connectionSvc) shouldLimit(addr net.Addr) bool {
-	if s.cfg.Options().LimitBandwidthInLan {
-		return true
-	}
-
-	tcpaddr, ok := addr.(*net.TCPAddr)
-	if !ok {
-		return true
-	}
-	for _, lan := range lans {
-		if lan.Contains(tcpaddr.IP) {
-			return false
-		}
-	}
-	return !tcpaddr.IP.IsLoopback()
-}
-
-func (s *connectionSvc) VerifyConfiguration(from, to config.Configuration) error {
-	return nil
-}
-
-func (s *connectionSvc) CommitConfiguration(from, to config.Configuration) bool {
-	// We require a restart if a device as been removed.
-
-	newDevices := make(map[protocol.DeviceID]bool, len(to.Devices))
-	for _, dev := range to.Devices {
-		newDevices[dev.DeviceID] = true
-	}
-
-	for _, dev := range from.Devices {
-		if !newDevices[dev.DeviceID] {
-			return false
-		}
-	}
-
-	return true
-}

cmd/syncthing/debug.go

@@ -9,10 +9,20 @@ package main
 import (
 	"os"
 	"strings"
+
+	"github.com/syncthing/syncthing/lib/logger"
 )
 
 var (
-	debugNet    = strings.Contains(os.Getenv("STTRACE"), "net") || os.Getenv("STTRACE") == "all"
-	debugHTTP   = strings.Contains(os.Getenv("STTRACE"), "http") || os.Getenv("STTRACE") == "all"
-	debugSuture = strings.Contains(os.Getenv("STTRACE"), "suture") || os.Getenv("STTRACE") == "all"
+	l     = logger.DefaultLogger.NewFacility("main", "Main package")
+	httpl = logger.DefaultLogger.NewFacility("http", "REST API")
 )
+
+func shouldDebugHTTP() bool {
+	return l.ShouldDebug("http")
+}
+
+func init() {
+	l.SetDebug("main", strings.Contains(os.Getenv("STTRACE"), "main") || os.Getenv("STTRACE") == "all")
+	l.SetDebug("http", strings.Contains(os.Getenv("STTRACE"), "http") || os.Getenv("STTRACE") == "all")
+}

cmd/syncthing/gui_auth.go

@@ -15,7 +15,9 @@ import (
 	"time"
 
 	"github.com/syncthing/syncthing/lib/config"
+	"github.com/syncthing/syncthing/lib/events"
 	"github.com/syncthing/syncthing/lib/sync"
+	"github.com/syncthing/syncthing/lib/util"
 	"golang.org/x/crypto/bcrypt"
 )
 
@@ -24,10 +26,16 @@ var (
 	sessionsMut = sync.NewMutex()
 )
 
-func basicAuthAndSessionMiddleware(cookieName string, cfg config.GUIConfiguration, next http.Handler) http.Handler {
+func emitLoginAttempt(success bool, username string) {
+	events.Default.Log(events.LoginAttempt, map[string]interface{}{
+		"success":  success,
+		"username": username,
+	})
+}
 
+func basicAuthAndSessionMiddleware(cookieName string, cfg config.GUIConfiguration, next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if cfg.APIKey != "" && r.Header.Get("X-API-Key") == cfg.APIKey {
+		if cfg.IsValidAPIKey(r.Header.Get("X-API-Key")) {
 			next.ServeHTTP(w, r)
 			return
 		}
@@ -43,9 +51,7 @@ func basicAuthAndSessionMiddleware(cookieName string, cfg config.GUIConfiguratio
 			}
 		}
 
-		if debugHTTP {
-			l.Debugln("Sessionless HTTP request with authentication; this is expensive.")
-		}
+		httpl.Debugln("Sessionless HTTP request with authentication; this is expensive.")
 
 		error := func() {
 			time.Sleep(time.Duration(rand.Intn(100)+100) * time.Millisecond)
@@ -72,17 +78,20 @@ func basicAuthAndSessionMiddleware(cookieName string, cfg config.GUIConfiguratio
 			return
 		}
 
-		if string(fields[0]) != cfg.User {
+		username := string(fields[0])
+		if username != cfg.User {
+			emitLoginAttempt(false, username)
 			error()
 			return
 		}
 
 		if err := bcrypt.CompareHashAndPassword([]byte(cfg.Password), fields[1]); err != nil {
+			emitLoginAttempt(false, username)
 			error()
 			return
 		}
 
-		sessionid := randomString(32)
+		sessionid := util.RandomString(32)
 		sessionsMut.Lock()
 		sessions[sessionid] = true
 		sessionsMut.Unlock()
@@ -92,6 +101,7 @@ func basicAuthAndSessionMiddleware(cookieName string, cfg config.GUIConfiguratio
 			MaxAge: 0,
 		})
 
+		emitLoginAttempt(true, username)
 		next.ServeHTTP(w, r)
 	})
 }

cmd/syncthing/gui_csrf.go

@@ -13,21 +13,30 @@ import (
 	"os"
 	"strings"
 
+	"github.com/syncthing/syncthing/lib/config"
 	"github.com/syncthing/syncthing/lib/osutil"
 	"github.com/syncthing/syncthing/lib/sync"
+	"github.com/syncthing/syncthing/lib/util"
 )
 
+// csrfTokens is a list of valid tokens. It is sorted so that the most
+// recently used token is first in the list. New tokens are added to the front
+// of the list (as it is the most recently used at that time). The list is
+// pruned to a maximum of maxCsrfTokens, throwing away the least recently used
+// tokens.
 var csrfTokens []string
 var csrfMut = sync.NewMutex()
 
+const maxCsrfTokens = 25
+
 // Check for CSRF token on /rest/ URLs. If a correct one is not given, reject
 // the request with 403. For / and /index.html, set a new CSRF cookie if none
 // is currently set.
-func csrfMiddleware(unique, prefix, apiKey string, next http.Handler) http.Handler {
+func csrfMiddleware(unique string, prefix string, cfg config.GUIConfiguration, next http.Handler) http.Handler {
 	loadCsrfTokens()
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		// Allow requests carrying a valid API key
-		if apiKey != "" && r.Header.Get("X-API-Key") == apiKey {
+		if cfg.IsValidAPIKey(r.Header.Get("X-API-Key")) {
 			next.ServeHTTP(w, r)
 			return
 		}
@@ -36,6 +45,7 @@ func csrfMiddleware(unique, prefix, apiKey string, next http.Handler) http.Handl
 		if !strings.HasPrefix(r.URL.Path, prefix) {
 			cookie, err := r.Cookie("CSRF-Token-" + unique)
 			if err != nil || !validCsrfToken(cookie.Value) {
+				httpl.Debugln("new CSRF cookie in response to request for", r.URL)
 				cookie = &http.Cookie{
 					Name:  "CSRF-Token-" + unique,
 					Value: newCsrfToken(),
@@ -47,7 +57,13 @@ func csrfMiddleware(unique, prefix, apiKey string, next http.Handler) http.Handl
 		}
 
 		if r.Method == "GET" {
-			// Allow GET requests unconditionally
+			// Allow GET requests unconditionally, but if we got the CSRF
+			// token cookie do the verification anyway so we keep the
+			// csrfTokens list sorted by recent usage. We don't care about the
+			// outcome of the validity check.
+			if cookie, err := r.Cookie("CSRF-Token-" + unique); err == nil {
+				validCsrfToken(cookie.Value)
+			}
 			next.ServeHTTP(w, r)
 			return
 		}
@@ -66,8 +82,15 @@ func csrfMiddleware(unique, prefix, apiKey string, next http.Handler) http.Handl
 func validCsrfToken(token string) bool {
 	csrfMut.Lock()
 	defer csrfMut.Unlock()
-	for _, t := range csrfTokens {
+	for i, t := range csrfTokens {
 		if t == token {
+			if i > 0 {
+				// Move this token to the head of the list. Copy the tokens at
+				// the front one step to the right and then replace the token
+				// at the head.
+				copy(csrfTokens[1:], csrfTokens[:i+1])
+				csrfTokens[0] = token
+			}
 			return true
 		}
 	}
@@ -75,12 +98,12 @@ func validCsrfToken(token string) bool {
 }
 
 func newCsrfToken() string {
-	token := randomString(32)
+	token := util.RandomString(32)
 
 	csrfMut.Lock()
-	csrfTokens = append(csrfTokens, token)
-	if len(csrfTokens) > 10 {
-		csrfTokens = csrfTokens[len(csrfTokens)-10:]
+	csrfTokens = append([]string{token}, csrfTokens...)
+	if len(csrfTokens) > maxCsrfTokens {
+		csrfTokens = csrfTokens[:maxCsrfTokens]
 	}
 	defer csrfMut.Unlock()
 

cmd/syncthing/gui_test.go

@@ -0,0 +1,419 @@
+// Copyright (C) 2016 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package main
+
+import (
+	"bytes"
+	"compress/gzip"
+	"fmt"
+	"io/ioutil"
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/d4l3k/messagediff"
+	"github.com/syncthing/syncthing/lib/config"
+	"github.com/syncthing/syncthing/lib/protocol"
+	"github.com/syncthing/syncthing/lib/sync"
+	"github.com/thejerf/suture"
+)
+
+func TestCSRFToken(t *testing.T) {
+	t1 := newCsrfToken()
+	t2 := newCsrfToken()
+
+	t3 := newCsrfToken()
+	if !validCsrfToken(t3) {
+		t.Fatal("t3 should be valid")
+	}
+
+	for i := 0; i < 250; i++ {
+		if i%5 == 0 {
+			// t1 and t2 should remain valid by virtue of us checking them now
+			// and then.
+			if !validCsrfToken(t1) {
+				t.Fatal("t1 should be valid at iteration", i)
+			}
+			if !validCsrfToken(t2) {
+				t.Fatal("t2 should be valid at iteration", i)
+			}
+		}
+
+		// The newly generated token is always valid
+		t4 := newCsrfToken()
+		if !validCsrfToken(t4) {
+			t.Fatal("t4 should be valid at iteration", i)
+		}
+	}
+
+	if validCsrfToken(t3) {
+		t.Fatal("t3 should have expired by now")
+	}
+}
+
+func TestStopAfterBrokenConfig(t *testing.T) {
+	cfg := config.Configuration{
+		GUI: config.GUIConfiguration{
+			RawAddress: "127.0.0.1:0",
+			RawUseTLS:  false,
+		},
+	}
+	w := config.Wrap("/dev/null", cfg)
+
+	srv, err := newAPIService(protocol.LocalDeviceID, w, "../../test/h1/https-cert.pem", "../../test/h1/https-key.pem", "", nil, nil, nil, nil, nil, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	srv.started = make(chan struct{})
+
+	sup := suture.NewSimple("test")
+	sup.Add(srv)
+	sup.ServeBackground()
+
+	<-srv.started
+
+	// Service is now running, listening on a random port on localhost. Now we
+	// request a config change to a completely invalid listen address. The
+	// commit will fail and the service will be in a broken state.
+
+	newCfg := config.Configuration{
+		GUI: config.GUIConfiguration{
+			RawAddress: "totally not a valid address",
+			RawUseTLS:  false,
+		},
+	}
+	if srv.CommitConfiguration(cfg, newCfg) {
+		t.Fatal("Config commit should have failed")
+	}
+
+	// Nonetheless, it should be fine to Stop() it without panic.
+
+	sup.Stop()
+}
+
+func TestAssetsDir(t *testing.T) {
+	// For any given request to $FILE, we should return the first found of
+	//  - assetsdir/$THEME/$FILE
+	//  - compiled in asset $THEME/$FILE
+	//  - assetsdir/default/$FILE
+	//  - compiled in asset default/$FILE
+
+	// The asset map contains compressed assets, so create a couple of gzip compressed assets here.
+	buf := new(bytes.Buffer)
+	gw := gzip.NewWriter(buf)
+	gw.Write([]byte("default"))
+	gw.Close()
+	def := buf.Bytes()
+
+	buf = new(bytes.Buffer)
+	gw = gzip.NewWriter(buf)
+	gw.Write([]byte("foo"))
+	gw.Close()
+	foo := buf.Bytes()
+
+	e := embeddedStatic{
+		theme:    "foo",
+		mut:      sync.NewRWMutex(),
+		assetDir: "testdata",
+		assets: map[string][]byte{
+			"foo/a":     foo, // overridden in foo/a
+			"foo/b":     foo,
+			"default/a": def, // overridden in default/a (but foo/a takes precedence)
+			"default/b": def, // overridden in default/b (but foo/b takes precedence)
+			"default/c": def,
+		},
+	}
+
+	s := httptest.NewServer(e)
+	defer s.Close()
+
+	// assetsdir/foo/a exists, overrides compiled in
+	expectURLToContain(t, s.URL+"/a", "overridden-foo")
+
+	// foo/b is compiled in, default/b is overriden, return compiled in
+	expectURLToContain(t, s.URL+"/b", "foo")
+
+	// only exists as compiled in default/c so use that
+	expectURLToContain(t, s.URL+"/c", "default")
+
+	// only exists as overriden default/d so use that
+	expectURLToContain(t, s.URL+"/d", "overridden-default")
+}
+
+func expectURLToContain(t *testing.T, url, exp string) {
+	res, err := http.Get(url)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	if res.StatusCode != 200 {
+		t.Errorf("Got %s instead of 200 OK", res.Status)
+		return
+	}
+
+	data, err := ioutil.ReadAll(res.Body)
+	res.Body.Close()
+	if err != nil {
+		t.Error(err)
+		return
+	}
+
+	if string(data) != exp {
+		t.Errorf("Got %q instead of %q on %q", data, exp, url)
+		return
+	}
+}
+
+func TestDirNames(t *testing.T) {
+	names := dirNames("testdata")
+	expected := []string{"default", "foo", "testfolder"}
+	if diff, equal := messagediff.PrettyDiff(expected, names); !equal {
+		t.Errorf("Unexpected dirNames return: %#v\n%s", names, diff)
+	}
+}
+
+type httpTestCase struct {
+	URL     string        // URL to check
+	Code    int           // Expected result code
+	Type    string        // Expected content type
+	Prefix  string        // Expected result prefix
+	Timeout time.Duration // Defaults to a second
+}
+
+func TestAPIServiceRequests(t *testing.T) {
+	model := new(mockedModel)
+	cfg := new(mockedConfig)
+	httpsCertFile := "../../test/h1/https-cert.pem"
+	httpsKeyFile := "../../test/h1/https-key.pem"
+	assetDir := "../../gui"
+	eventSub := new(mockedEventSub)
+	discoverer := new(mockedCachingMux)
+	relayService := new(mockedRelayService)
+	errorLog := new(mockedLoggerRecorder)
+	systemLog := new(mockedLoggerRecorder)
+
+	// Instantiate the API service
+	svc, err := newAPIService(protocol.LocalDeviceID, cfg, httpsCertFile, httpsKeyFile, assetDir, model,
+		eventSub, discoverer, relayService, errorLog, systemLog)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_ = svc
+
+	// Make sure the API service is listening, and get the URL to use.
+	addr := svc.listener.Addr()
+	if addr == nil {
+		t.Fatal("Nil listening address from API service")
+	}
+	tcpAddr, err := net.ResolveTCPAddr("tcp", addr.String())
+	if err != nil {
+		t.Fatal("Weird address from API service:", err)
+	}
+	baseURL := fmt.Sprintf("http://127.0.0.1:%d", tcpAddr.Port)
+
+	// Actually start the API service
+	supervisor := suture.NewSimple("API test")
+	supervisor.Add(svc)
+	supervisor.ServeBackground()
+
+	cases := []httpTestCase{
+		// /rest/db
+		{
+			URL:    "/rest/db/completion?device=" + protocol.LocalDeviceID.String() + "&folder=default",
+			Code:   200,
+			Type:   "application/json",
+			Prefix: "{",
+		},
+		{
+			URL:  "/rest/db/file?folder=default&file=something",
+			Code: 404,
+		},
+		{
+			URL:    "/rest/db/ignores?folder=default",
+			Code:   200,
+			Type:   "application/json",
+			Prefix: "{",
+		},
+		{
+			URL:    "/rest/db/need?folder=default",
+			Code:   200,
+			Type:   "application/json",
+			Prefix: "{",
+		},
+		{
+			URL:    "/rest/db/status?folder=default",
+			Code:   200,
+			Type:   "application/json",
+			Prefix: "{",
+		},
+		{
+			URL:    "/rest/db/browse?folder=default",
+			Code:   200,
+			Type:   "application/json",
+			Prefix: "null",
+		},
+
+		// /rest/stats
+		{
+			URL:    "/rest/stats/device",
+			Code:   200,
+			Type:   "application/json",
+			Prefix: "null",
+		},
+		{
+			URL:    "/rest/stats/folder",
+			Code:   200,
+			Type:   "application/json",
+			Prefix: "null",
+		},
+
+		// /rest/svc
+		{
+			URL:    "/rest/svc/deviceid?id=" + protocol.LocalDeviceID.String(),
+			Code:   200,
+			Type:   "application/json",
+			Prefix: "{",
+		},
+		{
+			URL:    "/rest/svc/lang",
+			Code:   200,
+			Type:   "application/json",
+			Prefix: "[",
+		},
+		{
+			URL:     "/rest/svc/report",
+			Code:    200,
+			Type:    "application/json",
+			Prefix:  "{",
+			Timeout: 5 * time.Second,
+		},
+
+		// /rest/system
+		{
+			URL:    "/rest/system/browse?current=~",
+			Code:   200,
+			Type:   "application/json",
+			Prefix: "[",
+		},
+		{
+			URL:    "/rest/system/config",
+			Code:   200,
+			Type:   "application/json",
+			Prefix: "{",
+		},
+		{
+			URL:    "/rest/system/config/insync",
+			Code:   200,
+			Type:   "application/json",
+			Prefix: "{",
+		},
+		{
+			URL:    "/rest/system/connections",
+			Code:   200,
+			Type:   "application/json",
+			Prefix: "null",
+		},
+		{
+			URL:    "/rest/system/discovery",
+			Code:   200,
+			Type:   "application/json",
+			Prefix: "{",
+		},
+		{
+			URL:    "/rest/system/error?since=0",
+			Code:   200,
+			Type:   "application/json",
+			Prefix: "{",
+		},
+		{
+			URL:    "/rest/system/ping",
+			Code:   200,
+			Type:   "application/json",
+			Prefix: "{",
+		},
+		{
+			URL:    "/rest/system/status",
+			Code:   200,
+			Type:   "application/json",
+			Prefix: "{",
+		},
+		{
+			URL:    "/rest/system/version",
+			Code:   200,
+			Type:   "application/json",
+			Prefix: "{",
+		},
+		{
+			URL:    "/rest/system/debug",
+			Code:   200,
+			Type:   "application/json",
+			Prefix: "{",
+		},
+		{
+			URL:    "/rest/system/log?since=0",
+			Code:   200,
+			Type:   "application/json",
+			Prefix: "{",
+		},
+		{
+			URL:    "/rest/system/log.txt?since=0",
+			Code:   200,
+			Type:   "text/plain",
+			Prefix: "",
+		},
+	}
+
+	for _, tc := range cases {
+		t.Log("Testing", tc.URL, "...")
+		testHTTPRequest(t, baseURL, tc)
+	}
+}
+
+// testHTTPRequest tries the given test case, comparing the result code,
+// content type, and result prefix.
+func testHTTPRequest(t *testing.T, baseURL string, tc httpTestCase) {
+	timeout := time.Second
+	if tc.Timeout > 0 {
+		timeout = tc.Timeout
+	}
+	cli := &http.Client{
+		Timeout: timeout,
+	}
+
+	resp, err := cli.Get(baseURL + tc.URL)
+	if err != nil {
+		t.Errorf("Unexpected error requesting %s: %v", tc.URL, err)
+		return
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != tc.Code {
+		t.Errorf("Get on %s should have returned status code %d, not %s", tc.URL, tc.Code, resp.Status)
+		return
+	}
+
+	ct := resp.Header.Get("Content-Type")
+	if !strings.HasPrefix(ct, tc.Type) {
+		t.Errorf("The content type on %s should be %q, not %q", tc.URL, tc.Type, ct)
+		return
+	}
+
+	data, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		t.Errorf("Unexpected error reading %s: %v", tc.URL, err)
+		return
+	}
+
+	if !bytes.HasPrefix(data, []byte(tc.Prefix)) {
+		t.Errorf("Returned data from %s does not have prefix %q: %s", tc.URL, tc.Prefix, data)
+		return
+	}
+}

cmd/syncthing/locations.go

@@ -48,7 +48,7 @@ var locations = map[locationEnum]string{
 	locKeyFile:       "${config}/key.pem",
 	locHTTPSCertFile: "${config}/https-cert.pem",
 	locHTTPSKeyFile:  "${config}/https-key.pem",
-	locDatabase:      "${config}/index-v0.11.0.db",
+	locDatabase:      "${config}/index-v0.13.0.db",
 	locLogFile:       "${config}/syncthing.log", // -logfile on Windows
 	locCsrfTokens:    "${config}/csrftokens.txt",
 	locPanicLog:      "${config}/panic-${timestamp}.log",

cmd/syncthing/main_test.go

@@ -10,13 +10,10 @@ import (
 	"os"
 	"testing"
 
-	"github.com/syncthing/protocol"
 	"github.com/syncthing/syncthing/lib/config"
 	"github.com/syncthing/syncthing/lib/db"
 	"github.com/syncthing/syncthing/lib/model"
-
-	"github.com/syndtr/goleveldb/leveldb"
-	"github.com/syndtr/goleveldb/leveldb/storage"
+	"github.com/syncthing/syncthing/lib/protocol"
 )
 
 func TestFolderErrors(t *testing.T) {
@@ -38,11 +35,11 @@ func TestFolderErrors(t *testing.T) {
 		}
 	}
 
-	ldb, _ := leveldb.Open(storage.NewMemStorage(), nil)
+	ldb := db.OpenMemory()
 
 	// Case 1 - new folder, directory and marker created
 
-	m := model.NewModel(cfg, protocol.LocalDeviceID, "device", "syncthing", "dev", ldb)
+	m := model.NewModel(cfg, protocol.LocalDeviceID, "device", "syncthing", "dev", ldb, nil)
 	m.AddFolder(fcfg)
 
 	if err := m.CheckFolderHealth("folder"); err != nil {
@@ -73,7 +70,7 @@ func TestFolderErrors(t *testing.T) {
 		Folders: []config.FolderConfiguration{fcfg},
 	})
 
-	m = model.NewModel(cfg, protocol.LocalDeviceID, "device", "syncthing", "dev", ldb)
+	m = model.NewModel(cfg, protocol.LocalDeviceID, "device", "syncthing", "dev", ldb, nil)
 	m.AddFolder(fcfg)
 
 	if err := m.CheckFolderHealth("folder"); err != nil {
@@ -96,7 +93,7 @@ func TestFolderErrors(t *testing.T) {
 		{Name: "dummyfile"},
 	})
 
-	m = model.NewModel(cfg, protocol.LocalDeviceID, "device", "syncthing", "dev", ldb)
+	m = model.NewModel(cfg, protocol.LocalDeviceID, "device", "syncthing", "dev", ldb, nil)
 	m.AddFolder(fcfg)
 
 	if err := m.CheckFolderHealth("folder"); err == nil || err.Error() != "folder marker missing" {
@@ -127,7 +124,7 @@ func TestFolderErrors(t *testing.T) {
 		Folders: []config.FolderConfiguration{fcfg},
 	})
 
-	m = model.NewModel(cfg, protocol.LocalDeviceID, "device", "syncthing", "dev", ldb)
+	m = model.NewModel(cfg, protocol.LocalDeviceID, "device", "syncthing", "dev", ldb, nil)
 	m.AddFolder(fcfg)
 
 	if err := m.CheckFolderHealth("folder"); err == nil || err.Error() != "folder path missing" {
@@ -178,3 +175,29 @@ func TestShortIDCheck(t *testing.T) {
 		t.Error("Should have gotten an error")
 	}
 }
+
+func TestAllowedVersions(t *testing.T) {
+	testcases := []struct {
+		ver     string
+		allowed bool
+	}{
+		{"v0.13.0", true},
+		{"v0.12.11+22-gabcdef0", true},
+		{"v0.13.0-beta0", true},
+		{"v0.13.0-beta47", true},
+		{"v0.13.0-beta47+1-gabcdef0", true},
+		{"v0.13.0-beta.0", true},
+		{"v0.13.0-beta.47", true},
+		{"v0.13.0-beta.0+1-gabcdef0", true},
+		{"v0.13.0-beta.47+1-gabcdef0", true},
+		{"v0.13.0-some-weird-but-allowed-tag", true},
+		{"v0.13.0-allowed.to.do.this", true},
+		{"v0.13.0+not.allowed.to.do.this", false},
+	}
+
+	for i, c := range testcases {
+		if allowed := allowedVersionExp.MatchString(c.ver); allowed != c.allowed {
+			t.Errorf("%d: incorrect result %v != %v for %q", i, allowed, c.allowed, c.ver)
+		}
+	}
+}

cmd/syncthing/mocked_config_test.go

@@ -0,0 +1,44 @@
+// Copyright (C) 2016 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package main
+
+import (
+	"github.com/syncthing/syncthing/lib/config"
+	"github.com/syncthing/syncthing/lib/protocol"
+)
+
+type mockedConfig struct{}
+
+func (c *mockedConfig) GUI() config.GUIConfiguration {
+	return config.GUIConfiguration{}
+}
+
+func (c *mockedConfig) Raw() config.Configuration {
+	return config.Configuration{}
+}
+
+func (c *mockedConfig) Options() config.OptionsConfiguration {
+	return config.OptionsConfiguration{}
+}
+
+func (c *mockedConfig) Replace(cfg config.Configuration) config.CommitResponse {
+	return config.CommitResponse{}
+}
+
+func (c *mockedConfig) Subscribe(cm config.Committer) {}
+
+func (c *mockedConfig) Folders() map[string]config.FolderConfiguration {
+	return nil
+}
+
+func (c *mockedConfig) Devices() map[protocol.DeviceID]config.DeviceConfiguration {
+	return nil
+}
+
+func (c *mockedConfig) Save() error {
+	return nil
+}

cmd/syncthing/mocked_discovery_test.go

@@ -0,0 +1,52 @@
+// Copyright (C) 2016 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package main
+
+import (
+	"time"
+
+	"github.com/syncthing/syncthing/lib/discover"
+	"github.com/syncthing/syncthing/lib/protocol"
+)
+
+type mockedCachingMux struct{}
+
+// from suture.Service
+
+func (m *mockedCachingMux) Serve() {
+	select {}
+}
+
+func (m *mockedCachingMux) Stop() {
+}
+
+// from events.Finder
+
+func (m *mockedCachingMux) Lookup(deviceID protocol.DeviceID) (direct []string, relays []discover.Relay, err error) {
+	return nil, nil, nil
+}
+
+func (m *mockedCachingMux) Error() error {
+	return nil
+}
+
+func (m *mockedCachingMux) String() string {
+	return "mockedCachingMux"
+}
+
+func (m *mockedCachingMux) Cache() map[protocol.DeviceID]discover.CacheEntry {
+	return nil
+}
+
+// from events.CachingMux
+
+func (m *mockedCachingMux) Add(finder discover.Finder, cacheTime, negCacheTime time.Duration, priority int) {
+}
+
+func (m *mockedCachingMux) ChildErrors() map[string]error {
+	return nil
+}

cmd/syncthing/mocked_events_test.go

@@ -0,0 +1,15 @@
+// Copyright (C) 2016 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package main
+
+import "github.com/syncthing/syncthing/lib/events"
+
+type mockedEventSub struct{}
+
+func (s *mockedEventSub) Since(id int, into []events.Event) []events.Event {
+	select {}
+}

cmd/syncthing/mocked_logger_test.go

@@ -0,0 +1,26 @@
+// Copyright (C) 2016 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package main
+
+import (
+	"time"
+
+	"github.com/syncthing/syncthing/lib/logger"
+)
+
+type mockedLoggerRecorder struct{}
+
+func (r *mockedLoggerRecorder) Since(t time.Time) []logger.Line {
+	return []logger.Line{
+		{
+			When:    time.Now(),
+			Message: "Test message",
+		},
+	}
+}
+
+func (r *mockedLoggerRecorder) Clear() {}

cmd/syncthing/mocked_model_test.go

@@ -0,0 +1,115 @@
+// Copyright (C) 2016 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package main
+
+import (
+	"time"
+
+	"github.com/syncthing/syncthing/lib/db"
+	"github.com/syncthing/syncthing/lib/protocol"
+	"github.com/syncthing/syncthing/lib/stats"
+)
+
+type mockedModel struct{}
+
+func (m *mockedModel) GlobalDirectoryTree(folder, prefix string, levels int, dirsonly bool) map[string]interface{} {
+	return nil
+}
+
+func (m *mockedModel) Completion(device protocol.DeviceID, folder string) float64 {
+	return 0
+}
+
+func (m *mockedModel) Override(folder string) {}
+
+func (m *mockedModel) NeedFolderFiles(folder string, page, perpage int) ([]db.FileInfoTruncated, []db.FileInfoTruncated, []db.FileInfoTruncated, int) {
+	return nil, nil, nil, 0
+}
+
+func (m *mockedModel) NeedSize(folder string) (nfiles int, bytes int64) {
+	return 0, 0
+}
+
+func (m *mockedModel) ConnectionStats() map[string]interface{} {
+	return nil
+}
+
+func (m *mockedModel) DeviceStatistics() map[string]stats.DeviceStatistics {
+	return nil
+}
+
+func (m *mockedModel) FolderStatistics() map[string]stats.FolderStatistics {
+	return nil
+}
+
+func (m *mockedModel) CurrentFolderFile(folder string, file string) (protocol.FileInfo, bool) {
+	return protocol.FileInfo{}, false
+}
+
+func (m *mockedModel) CurrentGlobalFile(folder string, file string) (protocol.FileInfo, bool) {
+	return protocol.FileInfo{}, false
+}
+
+func (m *mockedModel) ResetFolder(folder string) {
+}
+
+func (m *mockedModel) Availability(folder, file string) []protocol.DeviceID {
+	return nil
+}
+
+func (m *mockedModel) GetIgnores(folder string) ([]string, []string, error) {
+	return nil, nil, nil
+}
+
+func (m *mockedModel) SetIgnores(folder string, content []string) error {
+	return nil
+}
+
+func (m *mockedModel) PauseDevice(device protocol.DeviceID) {
+}
+
+func (m *mockedModel) ResumeDevice(device protocol.DeviceID) {}
+
+func (m *mockedModel) DelayScan(folder string, next time.Duration) {}
+
+func (m *mockedModel) ScanFolder(folder string) error {
+	return nil
+}
+
+func (m *mockedModel) ScanFolders() map[string]error {
+	return nil
+}
+
+func (m *mockedModel) ScanFolderSubs(folder string, subs []string) error {
+	return nil
+}
+
+func (m *mockedModel) BringToFront(folder, file string) {}
+
+func (m *mockedModel) ConnectedTo(deviceID protocol.DeviceID) bool {
+	return false
+}
+
+func (m *mockedModel) GlobalSize(folder string) (nfiles, deleted int, bytes int64) {
+	return 0, 0, 0
+}
+
+func (m *mockedModel) LocalSize(folder string) (nfiles, deleted int, bytes int64) {
+	return 0, 0, 0
+}
+
+func (m *mockedModel) CurrentLocalVersion(folder string) (int64, bool) {
+	return 0, false
+}
+
+func (m *mockedModel) RemoteLocalVersion(folder string) (int64, bool) {
+	return 0, false
+}
+
+func (m *mockedModel) State(folder string) (string, time.Time, error) {
+	return "", time.Time{}, nil
+}

cmd/syncthing/mocked_relay_test.go

@@ -0,0 +1,37 @@
+// Copyright (C) 2016 The Syncthing Authors.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package main
+
+import (
+	"crypto/tls"
+	"time"
+)
+
+type mockedRelayService struct{}
+
+// from suture.Service
+
+func (s *mockedRelayService) Serve() {
+	select {}
+}
+
+func (s *mockedRelayService) Stop() {
+}
+
+// from relay.Service
+
+func (s *mockedRelayService) Accept() *tls.Conn {
+	return nil
+}
+
+func (s *mockedRelayService) Relays() []string {
+	return nil
+}
+
+func (s *mockedRelayService) RelayStatus(uri string) (time.Duration, bool) {
+	return 0, false
+}

cmd/syncthing/monitor.go

@@ -28,25 +28,22 @@ var (
 )
 
 const (
-	countRestarts = 4
-	loopThreshold = 60 * time.Second
+	countRestarts         = 4
+	loopThreshold         = 60 * time.Second
+	logFileAutoCloseDelay = 5 * time.Second
+	logFileMaxOpenTime    = time.Minute
 )
 
-func monitorMain() {
+func monitorMain(runtimeOptions RuntimeOptions) {
 	os.Setenv("STNORESTART", "yes")
 	os.Setenv("STMONITORED", "yes")
 	l.SetPrefix("[monitor] ")
 
-	var err error
 	var dst io.Writer = os.Stdout
 
-	if logFile != "" {
-		var fileDst io.Writer
-
-		fileDst, err = os.Create(logFile)
-		if err != nil {
-			l.Fatalln("log file:", err)
-		}
+	logFile := runtimeOptions.logFile
+	if logFile != "-" {
+		var fileDst io.Writer = newAutoclosedFile(logFile, logFileAutoCloseDelay, logFileMaxOpenTime)
 
 		if runtime.GOOS == "windows" {
 			// Translate line breaks to Windows standard
@@ -66,9 +63,12 @@ func monitorMain() {
 	args := os.Args
 	var restarts [countRestarts]time.Time
 
-	sign := make(chan os.Signal, 1)
-	sigTerm := syscall.Signal(0xf)
-	signal.Notify(sign, os.Interrupt, sigTerm, os.Kill)
+	stopSign := make(chan os.Signal, 1)
+	sigTerm := syscall.Signal(15)
+	signal.Notify(stopSign, os.Interrupt, sigTerm)
+	restartSign := make(chan os.Signal, 1)
+	sigHup := syscall.Signal(1)
+	signal.Notify(restartSign, sigHup)
 
 	for {
 		if t := time.Since(restarts[0]); t < loopThreshold {
@@ -128,12 +128,17 @@ func monitorMain() {
 		}()
 
 		select {
-		case s := <-sign:
+		case s := <-stopSign:
 			l.Infof("Signal %d received; exiting", s)
 			cmd.Process.Kill()
 			<-exit
 			return
 
+		case s := <-restartSign:
+			l.Infof("Signal %d received; restarting", s)
+			cmd.Process.Signal(sigHup)
+			err = <-exit
+
 		case err = <-exit:
 			if err == nil {
 				// Successful exit indicates an intentional shutdown
@@ -262,3 +267,114 @@ func restartMonitorWindows(args []string) error {
 	cmd.Stdin = os.Stdin
 	return cmd.Start()
 }
+
+// An autoclosedFile is an io.WriteCloser that opens itself for appending on
+// Write() and closes itself after an interval of no writes (closeDelay) or
+// when the file has been open for too long (maxOpenTime). A call to Write()
+// will return any error that happens on the resulting Open() call too. Errors
+// on automatic Close() calls are silently swallowed...
+type autoclosedFile struct {
+	name        string        // path to write to
+	closeDelay  time.Duration // close after this long inactivity
+	maxOpenTime time.Duration // or this long after opening
+
+	fd         io.WriteCloser // underlying WriteCloser
+	opened     time.Time      // timestamp when the file was last opened
+	closed     chan struct{}  // closed on Close(), stops the closerLoop
+	closeTimer *time.Timer    // fires closeDelay after a write
+
+	mut sync.Mutex
+}
+
+func newAutoclosedFile(name string, closeDelay, maxOpenTime time.Duration) *autoclosedFile {
+	f := &autoclosedFile{
+		name:        name,
+		closeDelay:  closeDelay,
+		maxOpenTime: maxOpenTime,
+		mut:         sync.NewMutex(),
+		closed:      make(chan struct{}),
+		closeTimer:  time.NewTimer(time.Minute),
+	}
+	go f.closerLoop()
+	return f
+}
+
+func (f *autoclosedFile) Write(bs []byte) (int, error) {
+	f.mut.Lock()
+	defer f.mut.Unlock()
+
+	// Make sure the file is open for appending
+	if err := f.ensureOpen(); err != nil {
+		return 0, err
+	}
+
+	// If we haven't run into the maxOpenTime, postpone close for another
+	// closeDelay
+	if time.Since(f.opened) < f.maxOpenTime {
+		f.closeTimer.Reset(f.closeDelay)
+	}
+
+	return f.fd.Write(bs)
+}
+
+func (f *autoclosedFile) Close() error {
+	f.mut.Lock()
+	defer f.mut.Unlock()
+
+	// Stop the timer and closerLoop() routine
+	f.closeTimer.Stop()
+	close(f.closed)
+
+	// Close the file, if it's open
+	if f.fd != nil {
+		return f.fd.Close()
+	}
+
+	return nil
+}
+
+// Must be called with f.mut held!
+func (f *autoclosedFile) ensureOpen() error {
+	if f.fd != nil {
+		// File is already open
+		return nil
+	}
+
+	// We open the file for write only, and create it if it doesn't exist.
+	flags := os.O_WRONLY | os.O_CREATE
+	if f.opened.IsZero() {
+		// This is the first time we are opening the file. We should truncate
+		// it to better emulate an os.Create() call.
+		flags |= os.O_TRUNC
+	} else {
+		// The file was already opened once, so we should append to it.
+		flags |= os.O_APPEND
+	}
+
+	fd, err := os.OpenFile(f.name, flags, 0644)
+	if err != nil {
+		return err
+	}
+
+	f.fd = fd
+	f.opened = time.Now()
+	return nil
+}
+
+func (f *autoclosedFile) closerLoop() {
+	for {
+		select {
+		case <-f.closeTimer.C:
+			// Close the file when the timer expires.
+			f.mut.Lock()
+			if f.fd != nil {
+				f.fd.Close() // errors, schmerrors
+				f.fd = nil
+			}
+			f.mut.Unlock()
+
+		case <-f.closed:
+			return
+		}
+	}
+}

cmd/syncthing/perfstats_unix.go

@@ -15,7 +15,7 @@ import (
 	"syscall"
 	"time"
 
-	"github.com/syncthing/protocol"
+	"github.com/syncthing/syncthing/lib/protocol"
 )
 
 func init() {

cmd/syncthing/summaryservice.go

@@ -10,17 +10,17 @@ import (
 	"time"
 
 	"github.com/syncthing/syncthing/lib/events"
-	"github.com/syncthing/syncthing/lib/model"
 	"github.com/syncthing/syncthing/lib/sync"
 	"github.com/thejerf/suture"
 )
 
-// The folderSummarySvc adds summary information events (FolderSummary and
+// The folderSummaryService adds summary information events (FolderSummary and
 // FolderCompletion) into the event stream at certain intervals.
-type folderSummarySvc struct {
+type folderSummaryService struct {
 	*suture.Supervisor
 
-	model     *model.Model
+	cfg       configIntf
+	model     modelIntf
 	stop      chan struct{}
 	immediate chan string
 
@@ -33,9 +33,10 @@ type folderSummarySvc struct {
 	lastEventReqMut sync.Mutex
 }
 
-func newFolderSummarySvc(m *model.Model) *folderSummarySvc {
-	svc := &folderSummarySvc{
-		Supervisor:      suture.NewSimple("folderSummarySvc"),
+func newFolderSummaryService(cfg configIntf, m modelIntf) *folderSummaryService {
+	service := &folderSummaryService{
+		Supervisor:      suture.NewSimple("folderSummaryService"),
+		cfg:             cfg,
 		model:           m,
 		stop:            make(chan struct{}),
 		immediate:       make(chan string),
@@ -44,20 +45,20 @@ func newFolderSummarySvc(m *model.Model) *folderSummarySvc {
 		lastEventReqMut: sync.NewMutex(),
 	}
 
-	svc.Add(serviceFunc(svc.listenForUpdates))
-	svc.Add(serviceFunc(svc.calculateSummaries))
+	service.Add(serviceFunc(service.listenForUpdates))
+	service.Add(serviceFunc(service.calculateSummaries))
 
-	return svc
+	return service
 }
 
-func (c *folderSummarySvc) Stop() {
+func (c *folderSummaryService) Stop() {
 	c.Supervisor.Stop()
 	close(c.stop)
 }
 
 // listenForUpdates subscribes to the event bus and makes note of folders that
 // need their data recalculated.
-func (c *folderSummarySvc) listenForUpdates() {
+func (c *folderSummaryService) listenForUpdates() {
 	sub := events.Default.Subscribe(events.LocalIndexUpdated | events.RemoteIndexUpdated | events.StateChanged)
 	defer events.Default.Unsubscribe(sub)
 
@@ -107,7 +108,7 @@ func (c *folderSummarySvc) listenForUpdates() {
 
 // calculateSummaries periodically recalculates folder summaries and
 // completion percentage, and sends the results on the event bus.
-func (c *folderSummarySvc) calculateSummaries() {
+func (c *folderSummaryService) calculateSummaries() {
 	const pumpInterval = 2 * time.Second
 	pump := time.NewTimer(pumpInterval)
 
@@ -136,7 +137,7 @@ func (c *folderSummarySvc) calculateSummaries() {
 
 // foldersToHandle returns the list of folders needing a summary update, and
 // clears the list.
-func (c *folderSummarySvc) foldersToHandle() []string {
+func (c *folderSummaryService) foldersToHandle() []string {
 	// We only recalculate summaries if someone is listening to events
 	// (a request to /rest/events has been made within the last
 	// pingEventInterval).
@@ -159,16 +160,16 @@ func (c *folderSummarySvc) foldersToHandle() []string {
 }
 
 // sendSummary send the summary events for a single folder
-func (c *folderSummarySvc) sendSummary(folder string) {
+func (c *folderSummaryService) sendSummary(folder string) {
 	// The folder summary contains how many bytes, files etc
 	// are in the folder and how in sync we are.
-	data := folderSummary(c.model, folder)
+	data := folderSummary(c.cfg, c.model, folder)
 	events.Default.Log(events.FolderSummary, map[string]interface{}{
 		"folder":  folder,
 		"summary": data,
 	})
 
-	for _, devCfg := range cfg.Folders()[folder].Devices {
+	for _, devCfg := range c.cfg.Folders()[folder].Devices {
 		if devCfg.DeviceID.Equals(myID) {
 			// We already know about ourselves.
 			continue
@@ -189,7 +190,7 @@ func (c *folderSummarySvc) sendSummary(folder string) {
 	}
 }
 
-func (c *folderSummarySvc) gotEventRequest() {
+func (c *folderSummaryService) gotEventRequest() {
 	c.lastEventReqMut.Lock()
 	c.lastEventReq = time.Now()
 	c.lastEventReqMut.Unlock()

cmd/syncthing/testdata/default/a

@@ -0,0 +1 @@
+overridden-default

cmd/syncthing/testdata/default/b

@@ -0,0 +1 @@
+overridden-default

cmd/syncthing/testdata/default/d

@@ -0,0 +1 @@
+overridden-default

cmd/syncthing/testdata/foo/a

@@ -0,0 +1 @@
+overridden-foo

cmd/syncthing/tls.go

@@ -1,126 +0,0 @@
-// Copyright (C) 2014 The Syncthing Authors.
-//
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v. 2.0. If a copy of the MPL was not distributed with this file,
-// You can obtain one at http://mozilla.org/MPL/2.0/.
-
-package main
-
-import (
-	"bufio"
-	"crypto/rand"
-	"crypto/rsa"
-	"crypto/tls"
-	"crypto/x509"
-	"crypto/x509/pkix"
-	"encoding/pem"
-	"io"
-	"math/big"
-	mr "math/rand"
-	"net"
-	"os"
-	"time"
-)
-
-const (
-	tlsRSABits           = 3072
-	tlsDefaultCommonName = "syncthing"
-)
-
-func newCertificate(certFile, keyFile, name string) (tls.Certificate, error) {
-	l.Infof("Generating RSA key and certificate for %s...", name)
-
-	priv, err := rsa.GenerateKey(rand.Reader, tlsRSABits)
-	if err != nil {
-		l.Fatalln("generate key:", err)
-	}
-
-	notBefore := time.Now()
-	notAfter := time.Date(2049, 12, 31, 23, 59, 59, 0, time.UTC)
-
-	template := x509.Certificate{
-		SerialNumber: new(big.Int).SetInt64(mr.Int63()),
-		Subject: pkix.Name{
-			CommonName: name,
-		},
-		NotBefore: notBefore,
-		NotAfter:  notAfter,
-
-		KeyUsage:              x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
-		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth, x509.ExtKeyUsageClientAuth},
-		BasicConstraintsValid: true,
-	}
-
-	derBytes, err := x509.CreateCertificate(rand.Reader, &template, &template, &priv.PublicKey, priv)
-	if err != nil {
-		l.Fatalln("create cert:", err)
-	}
-
-	certOut, err := os.Create(certFile)
-	if err != nil {
-		l.Fatalln("save cert:", err)
-	}
-	err = pem.Encode(certOut, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes})
-	if err != nil {
-		l.Fatalln("save cert:", err)
-	}
-	err = certOut.Close()
-	if err != nil {
-		l.Fatalln("save cert:", err)
-	}
-
-	keyOut, err := os.OpenFile(keyFile, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
-	if err != nil {
-		l.Fatalln("save key:", err)
-	}
-	err = pem.Encode(keyOut, &pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(priv)})
-	if err != nil {
-		l.Fatalln("save key:", err)
-	}
-	err = keyOut.Close()
-	if err != nil {
-		l.Fatalln("save key:", err)
-	}
-
-	return tls.LoadX509KeyPair(certFile, keyFile)
-}
-
-type DowngradingListener struct {
-	net.Listener
-	TLSConfig *tls.Config
-}
-
-type WrappedConnection struct {
-	io.Reader
-	net.Conn
-}
-
-func (l *DowngradingListener) Accept() (net.Conn, error) {
-	conn, err := l.Listener.Accept()
-	if err != nil {
-		return nil, err
-	}
-
-	br := bufio.NewReader(conn)
-	conn.SetReadDeadline(time.Now().Add(1 * time.Second))
-	bs, err := br.Peek(1)
-	conn.SetReadDeadline(time.Time{})
-	if err != nil {
-		// We hit a read error here, but the Accept() call succeeded so we must not return an error.
-		// We return the connection as is and let whoever tries to use it deal with the error.
-		return conn, nil
-	}
-
-	wrapper := &WrappedConnection{br, conn}
-
-	// 0x16 is the first byte of a TLS handshake
-	if bs[0] == 0x16 {
-		return tls.Server(wrapper, l.TLSConfig), nil
-	}
-
-	return wrapper, nil
-}
-
-func (c *WrappedConnection) Read(b []byte) (n int, err error) {
-	return c.Reader.Read(b)
-}

cmd/syncthing/usage_report.go

@@ -10,30 +10,36 @@ import (
 	"bytes"
 	"crypto/rand"
 	"crypto/sha256"
+	"crypto/tls"
 	"encoding/json"
 	"fmt"
-	"net"
 	"net/http"
 	"runtime"
+	"sort"
 	"time"
 
 	"github.com/syncthing/syncthing/lib/config"
+	"github.com/syncthing/syncthing/lib/dialer"
 	"github.com/syncthing/syncthing/lib/model"
+	"github.com/syncthing/syncthing/lib/protocol"
+	"github.com/syncthing/syncthing/lib/upgrade"
 	"github.com/thejerf/suture"
 )
 
 // Current version number of the usage report, for acceptance purposes. If
 // fields are added or changed this integer must be incremented so that users
 // are prompted for acceptance of the new report.
-const usageReportVersion = 1
+const usageReportVersion = 2
 
 type usageReportingManager struct {
+	cfg   *config.Wrapper
 	model *model.Model
 	sup   *suture.Supervisor
 }
 
-func newUsageReportingManager(m *model.Model, cfg *config.Wrapper) *usageReportingManager {
+func newUsageReportingManager(cfg *config.Wrapper, m *model.Model) *usageReportingManager {
 	mgr := &usageReportingManager{
+		cfg:   cfg,
 		model: m,
 	}
 
@@ -54,11 +60,9 @@ func (m *usageReportingManager) VerifyConfiguration(from, to config.Configuratio
 func (m *usageReportingManager) CommitConfiguration(from, to config.Configuration) bool {
 	if to.Options.URAccepted >= usageReportVersion && m.sup == nil {
 		// Usage reporting was turned on; lets start it.
-		svc := &usageReportingService{
-			model: m.model,
-		}
+		service := newUsageReportingService(m.cfg, m.model)
 		m.sup = suture.NewSimple("usageReporting")
-		m.sup.Add(svc)
+		m.sup.Add(service)
 		m.sup.ServeBackground()
 	} else if to.Options.URAccepted < usageReportVersion && m.sup != nil {
 		// Usage reporting was turned off
@@ -74,9 +78,10 @@ func (m *usageReportingManager) String() string {
 }
 
 // reportData returns the data to be sent in a usage report. It's used in
-// various places, so not part of the usageReportingSvc object.
-func reportData(m *model.Model) map[string]interface{} {
+// various places, so not part of the usageReportingManager object.
+func reportData(cfg configIntf, m modelIntf) map[string]interface{} {
 	res := make(map[string]interface{})
+	res["urVersion"] = usageReportVersion
 	res["uniqueID"] = cfg.Options().URUniqueID
 	res["version"] = Version
 	res["longVersion"] = LongVersion
@@ -106,45 +111,149 @@ func reportData(m *model.Model) map[string]interface{} {
 	var mem runtime.MemStats
 	runtime.ReadMemStats(&mem)
 	res["memoryUsageMiB"] = (mem.Sys - mem.HeapReleased) / 1024 / 1024
-
-	var perf float64
-	for i := 0; i < 5; i++ {
-		p := cpuBench()
-		if p > perf {
-			perf = p
-		}
-	}
-	res["sha256Perf"] = perf
+	res["sha256Perf"] = cpuBench(5, 125*time.Millisecond)
 
 	bytes, err := memorySize()
 	if err == nil {
 		res["memorySize"] = bytes / 1024 / 1024
 	}
+	res["numCPU"] = runtime.NumCPU()
+
+	var rescanIntvs []int
+	folderUses := map[string]int{
+		"readonly":            0,
+		"ignorePerms":         0,
+		"ignoreDelete":        0,
+		"autoNormalize":       0,
+		"simpleVersioning":    0,
+		"externalVersioning":  0,
+		"staggeredVersioning": 0,
+		"trashcanVersioning":  0,
+	}
+	for _, cfg := range cfg.Folders() {
+		rescanIntvs = append(rescanIntvs, cfg.RescanIntervalS)
+
+		if cfg.ReadOnly {
+			folderUses["readonly"]++
+		}
+		if cfg.IgnorePerms {
+			folderUses["ignorePerms"]++
+		}
+		if cfg.IgnoreDelete {
+			folderUses["ignoreDelete"]++
+		}
+		if cfg.AutoNormalize {
+			folderUses["autoNormalize"]++
+		}
+		if cfg.Versioning.Type != "" {
+			folderUses[cfg.Versioning.Type+"Versioning"]++
+		}
+	}
+	sort.Ints(rescanIntvs)
+	res["rescanIntvs"] = rescanIntvs
+	res["folderUses"] = folderUses
+
+	deviceUses := map[string]int{
+		"introducer":       0,
+		"customCertName":   0,
+		"compressAlways":   0,
+		"compressMetadata": 0,
+		"compressNever":    0,
+		"dynamicAddr":      0,
+		"staticAddr":       0,
+	}
+	for _, cfg := range cfg.Devices() {
+		if cfg.Introducer {
+			deviceUses["introducer"]++
+		}
+		if cfg.CertName != "" && cfg.CertName != "syncthing" {
+			deviceUses["customCertName"]++
+		}
+		if cfg.Compression == protocol.CompressAlways {
+			deviceUses["compressAlways"]++
+		} else if cfg.Compression == protocol.CompressMetadata {
+			deviceUses["compressMetadata"]++
+		} else if cfg.Compression == protocol.CompressNever {
+			deviceUses["compressNever"]++
+		}
+		for _, addr := range cfg.Addresses {
+			if addr == "dynamic" {
+				deviceUses["dynamicAddr"]++
+			} else {
+				deviceUses["staticAddr"]++
+			}
+		}
+	}
+	res["deviceUses"] = deviceUses
+
+	defaultAnnounceServersDNS, defaultAnnounceServersIP, otherAnnounceServers := 0, 0, 0
+	for _, addr := range cfg.Options().GlobalAnnServers {
+		if addr == "default" || addr == "default-v4" || addr == "default-v6" {
+			defaultAnnounceServersDNS++
+		} else {
+			otherAnnounceServers++
+		}
+	}
+	res["announce"] = map[string]interface{}{
+		"globalEnabled":     cfg.Options().GlobalAnnEnabled,
+		"localEnabled":      cfg.Options().LocalAnnEnabled,
+		"defaultServersDNS": defaultAnnounceServersDNS,
+		"defaultServersIP":  defaultAnnounceServersIP,
+		"otherServers":      otherAnnounceServers,
+	}
+
+	defaultRelayServers, otherRelayServers := 0, 0
+	for _, addr := range cfg.Options().RelayServers {
+		switch addr {
+		case "dynamic+https://relays.syncthing.net/endpoint":
+			defaultRelayServers++
+		default:
+			otherRelayServers++
+		}
+	}
+	res["relays"] = map[string]interface{}{
+		"enabled":        cfg.Options().RelaysEnabled,
+		"defaultServers": defaultRelayServers,
+		"otherServers":   otherRelayServers,
+	}
+
+	res["usesRateLimit"] = cfg.Options().MaxRecvKbps > 0 || cfg.Options().MaxSendKbps > 0
+
+	res["upgradeAllowedManual"] = !(upgrade.DisabledByCompilation || noUpgrade)
+	res["upgradeAllowedAuto"] = !(upgrade.DisabledByCompilation || noUpgrade) && cfg.Options().AutoUpgradeIntervalH > 0
 
 	return res
 }
 
 type usageReportingService struct {
+	cfg   *config.Wrapper
 	model *model.Model
 	stop  chan struct{}
 }
 
+func newUsageReportingService(cfg *config.Wrapper, model *model.Model) *usageReportingService {
+	return &usageReportingService{
+		cfg:   cfg,
+		model: model,
+		stop:  make(chan struct{}),
+	}
+}
+
 func (s *usageReportingService) sendUsageReport() error {
-	d := reportData(s.model)
+	d := reportData(s.cfg, s.model)
 	var b bytes.Buffer
 	json.NewEncoder(&b).Encode(d)
 
-	var client = http.DefaultClient
-	if BuildEnv == "android" {
-		// This works around the lack of DNS resolution on Android... :(
-		tr := &http.Transport{
-			Dial: func(network, addr string) (net.Conn, error) {
-				return net.Dial(network, "194.126.249.13:443")
+	client := &http.Client{
+		Transport: &http.Transport{
+			Dial:  dialer.Dial,
+			Proxy: http.ProxyFromEnvironment,
+			TLSClientConfig: &tls.Config{
+				InsecureSkipVerify: s.cfg.Options().URPostInsecurely,
 			},
-		}
-		client = &http.Client{Transport: tr}
+		},
 	}
-	_, err := client.Post("https://data.syncthing.net/newdata", "application/json", &b)
+	_, err := client.Post(s.cfg.Options().URURL, "application/json", &b)
 	return err
 }
 
@@ -154,7 +263,7 @@ func (s *usageReportingService) Serve() {
 	l.Infoln("Starting usage reporting")
 	defer l.Infoln("Stopping usage reporting")
 
-	t := time.NewTimer(10 * time.Minute) // time to initial report at start
+	t := time.NewTimer(time.Duration(s.cfg.Options().URInitialDelayS) * time.Second) // time to initial report at start
 	for {
 		select {
 		case <-s.stop:
@@ -174,7 +283,17 @@ func (s *usageReportingService) Stop() {
 }
 
 // cpuBench returns CPU performance as a measure of single threaded SHA-256 MiB/s
-func cpuBench() float64 {
+func cpuBench(iterations int, duration time.Duration) float64 {
+	var perf float64
+	for i := 0; i < iterations; i++ {
+		if v := cpuBenchOnce(duration); v > perf {
+			perf = v
+		}
+	}
+	return perf
+}
+
+func cpuBenchOnce(duration time.Duration) float64 {
 	chunkSize := 100 * 1 << 10
 	h := sha256.New()
 	bs := make([]byte, chunkSize)
@@ -182,7 +301,7 @@ func cpuBench() float64 {
 
 	t0 := time.Now()
 	b := 0
-	for time.Since(t0) < 125*time.Millisecond {
+	for time.Since(t0) < duration {
 		h.Write(bs)
 		b += chunkSize
 	}

cmd/syncthing/verboseservice.go

@@ -8,31 +8,38 @@ package main
 
 import (
 	"fmt"
+	"strings"
 
 	"github.com/syncthing/syncthing/lib/events"
 )
 
 // The verbose logging service subscribes to events and prints these in
 // verbose format to the console using INFO level.
-type verboseSvc struct {
+type verboseService struct {
 	stop    chan struct{} // signals time to stop
 	started chan struct{} // signals startup complete
 }
 
-func newVerboseSvc() *verboseSvc {
-	return &verboseSvc{
+func newVerboseService() *verboseService {
+	return &verboseService{
 		stop:    make(chan struct{}),
 		started: make(chan struct{}),
 	}
 }
 
 // Serve runs the verbose logging service.
-func (s *verboseSvc) Serve() {
+func (s *verboseService) Serve() {
 	sub := events.Default.Subscribe(events.AllEvents)
 	defer events.Default.Unsubscribe(sub)
 
-	// We're ready to start processing events.
-	close(s.started)
+	select {
+	case <-s.started:
+		// The started channel has already been closed; do nothing.
+	default:
+		// This is the first time around. Indicate that we're ready to start
+		// processing events.
+		close(s.started)
+	}
 
 	for {
 		select {
@@ -48,19 +55,19 @@ func (s *verboseSvc) Serve() {
 }
 
 // Stop stops the verbose logging service.
-func (s *verboseSvc) Stop() {
+func (s *verboseService) Stop() {
 	close(s.stop)
 }
 
 // WaitForStart returns once the verbose logging service is ready to receive
 // events, or immediately if it's already running.
-func (s *verboseSvc) WaitForStart() {
+func (s *verboseService) WaitForStart() {
 	<-s.started
 }
 
-func (s *verboseSvc) formatEvent(ev events.Event) string {
+func (s *verboseService) formatEvent(ev events.Event) string {
 	switch ev.Type {
-	case events.Ping, events.DownloadProgress:
+	case events.Ping, events.DownloadProgress, events.LocalIndexUpdated:
 		// Skip
 		return ""
 
@@ -74,7 +81,7 @@ func (s *verboseSvc) formatEvent(ev events.Event) string {
 		return fmt.Sprintf("Discovered device %v at %v", data["device"], data["addrs"])
 	case events.DeviceConnected:
 		data := ev.Data.(map[string]string)
-		return fmt.Sprintf("Connected to device %v at %v", data["id"], data["addr"])
+		return fmt.Sprintf("Connected to device %v at %v (type %s)", data["id"], data["addr"], data["type"])
 	case events.DeviceDisconnected:
 		data := ev.Data.(map[string]string)
 		return fmt.Sprintf("Disconnected from device %v", data["id"])
@@ -86,9 +93,6 @@ func (s *verboseSvc) formatEvent(ev events.Event) string {
 	case events.RemoteIndexUpdated:
 		data := ev.Data.(map[string]interface{})
 		return fmt.Sprintf("Device %v sent an index update for %q with %d items", data["device"], data["folder"], data["items"])
-	case events.LocalIndexUpdated:
-		data := ev.Data.(map[string]interface{})
-		return fmt.Sprintf("Updated index for folder %q with %v items", data["folder"], data["items"])
 
 	case events.DeviceRejected:
 		data := ev.Data.(map[string]interface{})
@@ -98,7 +102,7 @@ func (s *verboseSvc) formatEvent(ev events.Event) string {
 		return fmt.Sprintf("Rejected unshared folder %q from device %v", data["folder"], data["device"])
 
 	case events.ItemStarted:
-		data := ev.Data.(map[string]interface{})
+		data := ev.Data.(map[string]string)
 		return fmt.Sprintf("Started syncing %q / %q (%v %v)", data["folder"], data["item"], data["action"], data["type"])
 	case events.ItemFinished:
 		data := ev.Data.(map[string]interface{})
@@ -123,6 +127,46 @@ func (s *verboseSvc) formatEvent(ev events.Event) string {
 		delete(sum, "ignorePatterns")
 		delete(sum, "stateChanged")
 		return fmt.Sprintf("Summary for folder %q is %v", data["folder"], data["summary"])
+	case events.FolderScanProgress:
+		data := ev.Data.(map[string]interface{})
+		folder := data["folder"].(string)
+		current := data["current"].(int64)
+		total := data["total"].(int64)
+		rate := data["rate"].(float64) / 1024 / 1024
+		var pct int64
+		if total > 0 {
+			pct = 100 * current / total
+		}
+		return fmt.Sprintf("Scanning folder %q, %d%% done (%.01f MB/s)", folder, pct, rate)
+
+	case events.DevicePaused:
+		data := ev.Data.(map[string]string)
+		device := data["device"]
+		return fmt.Sprintf("Device %v was paused", device)
+	case events.DeviceResumed:
+		data := ev.Data.(map[string]string)
+		device := data["device"]
+		return fmt.Sprintf("Device %v was resumed", device)
+
+	case events.ExternalPortMappingChanged:
+		data := ev.Data.(map[string]int)
+		port := data["port"]
+		return fmt.Sprintf("External port mapping changed; new port is %d.", port)
+	case events.RelayStateChanged:
+		data := ev.Data.(map[string][]string)
+		newRelays := data["new"]
+		return fmt.Sprintf("Relay state changed; connected relay(s) are %s.", strings.Join(newRelays, ", "))
+	case events.LoginAttempt:
+		data := ev.Data.(map[string]interface{})
+		username := data["username"].(string)
+		var success string
+		if data["success"].(bool) {
+			success = "successful"
+		} else {
+			success = "failed"
+		}
+		return fmt.Sprintf("Login %s for username %s.", success, username)
+
 	}
 
 	return fmt.Sprintf("%s %#v", ev.Type, ev)

debian/changelog

@@ -0,0 +1,5 @@
+syncthing ({{.version}}); urgency=medium
+
+  * Packaging of {{.version}}.
+
+ -- Syncthing Release Management <release@syncthing.net>  {{.date}}

debian/compat

@@ -0,0 +1 @@
+9

debian/control

@@ -0,0 +1,16 @@
+Package: syncthing
+Version: {{.version}}
+Priority: optional
+Section: net
+Architecture: {{.arch}}
+Depends: libc6, procps
+Homepage: https://syncthing.net/
+Maintainer: Syncthing Release Management <release@syncthing.net>
+Description: Open Source Continuous File Synchronization
+ Syncthing is an application that lets you synchronize your files across
+ multiple devices. This means the creation, modification or deletion of files
+ on one machine will automatically be replicated to your other devices. We
+ believe your data is your data alone and you deserve to choose where it is
+ stored. Therefore Syncthing does not upload your data to the cloud but
+ exchanges your data across your machines as soon as they are online at the
+ same time.

debian/postinst

@@ -0,0 +1,6 @@
+#!/bin/bash
+set -euo pipefail
+
+if [[ ${1:-} == configure ]]; then
+	pkill -HUP -x syncthing || true
+fi

etc/linux-systemd/README.md

@@ -1,8 +1,8 @@
 # Systemd Configuration
 
-This directory contains configuration files for running syncthing under the
+This directory contains configuration files for running Syncthing under the
 "systemd" service manager on Linux both under either a systemd system service or
 systemd user service. For further documentation take a look at the [systemd
-section][1] on the Github Wiki.
+section][1] on http://docs.syncthing.net.
 
-[1]: http://docs.syncthing.net/users/autostart.html#systemd 
+[1]: http://docs.syncthing.net/users/autostart.html#systemd

etc/linux-systemd/system/syncthing-resume.service

@@ -0,0 +1,10 @@
+[Unit]
+Description=Restart Syncthing after resume
+After=suspend.target
+
+[Service]
+Type=oneshot
+ExecStart=/usr/bin/pkill -HUP -x syncthing
+
+[Install]
+WantedBy=suspend.target

etc/linux-systemd/system/syncthing@.service

@@ -1,14 +1,14 @@
 [Unit]
 Description=Syncthing - Open Source Continuous File Synchronization for %I
-Documentation=http://docs.syncthing.net/
+Documentation=man:syncthing(1)
 After=network.target
+Wants=syncthing-inotify@.service
 
 [Service]
 User=%i
-Environment=STNORESTART=yes
-ExecStart=/usr/bin/syncthing -no-browser -logflags=0
+ExecStart=/usr/bin/syncthing -no-browser -no-restart -logflags=0
 Restart=on-failure
-SuccessExitStatus=2 3 4
+SuccessExitStatus=3 4
 RestartForceExitStatus=3 4
 
 [Install]

etc/linux-systemd/user/syncthing.service

@@ -1,13 +1,13 @@
 [Unit]
 Description=Syncthing - Open Source Continuous File Synchronization
-Documentation=http://docs.syncthing.net/
+Documentation=man:syncthing(1)
 After=network.target
+Wants=syncthing-inotify.service
 
 [Service]
-Environment=STNORESTART=yes
-ExecStart=/usr/bin/syncthing -no-browser -logflags=0
+ExecStart=/usr/bin/syncthing -no-browser -no-restart -logflags=0
 Restart=on-failure
-SuccessExitStatus=2 3 4
+SuccessExitStatus=3 4
 RestartForceExitStatus=3 4
 
 [Install]

etc/linux-upstart/README.md

@@ -0,0 +1,16 @@
+# Upstart Configuration
+
+This directory contains example configuration files for running Syncthing under
+the "Upstart" service manager on Linux. To have syncthing start when you login
+place "user/syncthing.conf" in the "/home/[username]/.config/upstart/" folder.
+To have syncthing start when the system boots place "system/syncthing.conf"
+in the "/etc/init/" folder.
+To manualy start syncthing via Upstart when using the system configuration use:
+
+```
+    sudo initctl start syncthing
+```
+
+For further documentation see [http://docs.syncthing.net/users/autostart.html][1].
+
+[1]: http://docs.syncthing.net/users/autostart.html#Upstart

etc/linux-upstart/system/syncthing.conf

@@ -0,0 +1,13 @@
+description "Syncthing"
+
+start on (local-filesystems and net-device-up IFACE!=lo)
+stop on runlevel [!2345]
+
+env STNORESTART=yes
+env HOME=/home/$USER
+setuid "$USER"
+setgid "$USER"
+
+exec /usr/local/bin/syncthing
+
+respawn

etc/linux-upstart/user/syncthing.conf

@@ -0,0 +1,21 @@
+# Location of the syncthing executable
+env SYNCTHING_EXE="/usr/local/bin"
+
+# Set the name of the application
+description "Syncthing"
+
+# Start syncthing you login to your desktop
+start on desktop-start
+
+# Stop syncthing you logout of your desktop
+stop on desktop-end
+
+# Set STNORESTART to yes to have Upstart monitor the process instead
+# of having a separate syncthing process do the monitoring
+env STNORESTART=yes
+
+# If Upstart detects syncthing has failed - it should restart it
+respawn
+
+# the syncthing command Upstart is to execute when it is started up
+exec $SYNCTHING_EXE -no-browser

etc/windows/ReadMe.txt

@@ -1,13 +0,0 @@
-A first pass at an install script for SyncThing as a Windows Service
-
-Script uses NSIS http://nsis.sourceforge.net/Download
-Requires the NSIS Simple Service Plugin http://nsis.sourceforge.net/NSIS_Simple_Service_Plugin
-And uses the Windows Service Wrapper https://github.com/kohsuke/winsw
-
-To build the setup file:
-
- 1. Install NSIS, download the Simple Service Plugin DLL into the NSIS plugin folder
- 2. Create a folder (referenced by the $SOURCEPATH variable in the .nsi file) with all the syncthing output in it (exe file, licences, etc)
- 3. Download winsw.exe from https://github.com/kohsuke/winsw/releases, rename it to syncthingservice.exe and save that in $SOURCEPATH
- 4. Put syncthingservice.xml in there too
- 5. Compile SyncthingSetup.nsi using NSIS

etc/windows/SyncThingSetup.nsi

@@ -1,116 +0,0 @@
-;--------------------------------
-;Include Modern UI
-
-  !include "MUI2.nsh"
-
-;--------------------------------
-;General
-
-  ;Name and file
-  !define SOURCEPATH "C:\SourceCode\SyncThing\Binaries"
-  
-  Name "SyncThing Windows Service Install"
-  OutFile "SyncThingSetup.exe"
-
-  ;Default installation folder
-  InstallDir "$PROGRAMFILES\SyncThing"
-    
-  ;Get installation folder from registry if available
-  InstallDirRegKey HKCU "Software\SyncThing" ""
-
-  ;Request application privileges for Windows Vista
-  RequestExecutionLevel admin
-
-;--------------------------------
-;Interface Settings
-
-  !define MUI_ABORTWARNING
-
-;--------------------------------
-;Pages
-
-  !insertmacro MUI_PAGE_COMPONENTS
-  !insertmacro MUI_PAGE_DIRECTORY
-  !insertmacro MUI_PAGE_INSTFILES
-  
-  !insertmacro MUI_UNPAGE_CONFIRM
-  !insertmacro MUI_UNPAGE_INSTFILES
-  
-;--------------------------------
-;Languages
- 
-  !insertmacro MUI_LANGUAGE "English"
-
-;--------------------------------
-;Installer Sections
-
-Section "SyncThing" SecSyncThing
-  SectionIn RO
-  SetOutPath "$INSTDIR"
-  
-  IfFileExists syncthingservice.exe 0 +2
-	SimpleSC::StopService "SyncThing" 1 30	
-  
-  File /r "${SOURCEPATH}\syncthing.exe"
-  File /r "${SOURCEPATH}\syncthing.exe.md5"
-  File /r "${SOURCEPATH}\AUTHORS.txt"
-  File /r "${SOURCEPATH}\LICENSE.txt"
-  File /r "${SOURCEPATH}\README.txt"
-  File /r "${SOURCEPATH}\FAQ.pdf"
-  File /r "${SOURCEPATH}\Getting-Started.pdf"
-    
-  ;Store installation folder
-  WriteRegStr HKCU "Software\SyncThing" "" $INSTDIR
-  
-  ;Create uninstaller
-  WriteUninstaller "$INSTDIR\Uninstall.exe"
-
-SectionEnd
-
-Section "Command Line Interface" SecSyncThingCLI
-
-  SetOutPath "$INSTDIR"
-  
-  File /r "${SOURCEPATH}\syncthing-cli.exe"  
-  
-SectionEnd
-
-Section "Windows Service" SecSyncThingService
-
-  SetOutPath "$INSTDIR"
-    
-  File /r "${SOURCEPATH}\syncthingservice.exe"  
-  File /r "${SOURCEPATH}\syncthingservice.xml"  
-  
-  ExecWait 'syncthingservice.exe install'
-  ExecWait 'syncthingservice.exe start'
- 
-SectionEnd
-
-;--------------------------------
-;Descriptions
-
-  ;Language strings
-  LangString DESC_SecSyncThing ${LANG_ENGLISH} "SyncThing"
-  LangString DESC_SecSyncThingCLI ${LANG_ENGLISH} "Command Line Interface"
-  LangString DESC_SecSyncThingService ${LANG_ENGLISH} "Windows Service"
-
-  ;Assign language strings to sections
-  !insertmacro MUI_FUNCTION_DESCRIPTION_BEGIN
-    !insertmacro MUI_DESCRIPTION_TEXT ${SecSyncThing} $(DESC_SecSyncThing)
-	!insertmacro MUI_DESCRIPTION_TEXT ${SecSyncThingCLI} $(DESC_SecSyncThingCLI)
-	!insertmacro MUI_DESCRIPTION_TEXT ${SecSyncThingService} $(DESC_SecSyncThingService)
-  !insertmacro MUI_FUNCTION_DESCRIPTION_END
-
-;--------------------------------
-;Uninstaller Section
-
-Section "Uninstall"
-  
-  Delete "$INSTDIR\Uninstall.exe"
-
-  RMDir "$INSTDIR"
-
-  DeleteRegKey /ifempty HKCU "Software\SyncThing"
-
-SectionEnd

etc/windows/syncthingservice.xml

@@ -1,8 +0,0 @@
-<service>
-  <id>Syncthing</id>
-  <name>Syncthing</name>
-  <description>This service runs Syncthing</description>
-  <executable>syncthing.exe</executable>
-  <arguments>-home .\ServiceHome -no-console -no-browser</arguments>
-  <logmode>rotate</logmode>
-</service>

gui/assets/font/raleway.css

@@ -1,6 +0,0 @@
-@font-face {
-  font-family: 'Raleway';
-  font-style: normal;
-  font-weight: 500;
-  src: local('Raleway'), url(raleway-500.woff) format('woff');
-}

gui/assets/lang/lang-ro-RO.json

@@ -1,213 +0,0 @@
-{
-    "A negative number of days doesn't make sense.": "A negative number of days doesn't make sense.",
-    "A new major version may not be compatible with previous versions.": "A new major version may not be compatible with previous versions.",
-    "API Key": "Cheie API",
-    "About": "Despre",
-    "Actions": "Actions",
-    "Add": "Adaugă",
-    "Add Device": "Adaugă Dispozitiv",
-    "Add Folder": "Adaugă Mapă",
-    "Add new folder?": "Adauga o mapă nouă?",
-    "Address": "Adresă",
-    "Addresses": "Adrese",
-    "Advanced": "Advanced",
-    "Advanced Configuration": "Advanced Configuration",
-    "All Data": "Toate Datele",
-    "Allow Anonymous Usage Reporting?": "Permiteţi raportarea anonimă de folosire a aplicaţiei?",
-    "Alphabetic": "Alphabetic",
-    "An external command handles the versioning. It has to remove the file from the synced folder.": "O comandă externă administrează versiunile. Trebuie să şteargă documentul din fişierul sincronizat. ",
-    "Anonymous Usage Reporting": "Raport Anonim despre Folosirea Aplicației",
-    "Any devices configured on an introducer device will be added to this device as well.": "Toate dispozitivele configurate pe un dispozitiv iniţiator vor fi adăugate şi pe acest dispozitiv. ",
-    "Automatic upgrades": "Actualizare automată",
-    "Be careful!": "Be careful!",
-    "Bugs": "Bug-uri",
-    "CPU Utilization": "CPU ",
-    "Changelog": "Noutăți",
-    "Clean out after": "Clean out after",
-    "Close": "Închide",
-    "Command": "Comandă",
-    "Comment, when used at the start of a line": "Comentariu, când este folosit la începutul unei linii",
-    "Compression": "Compresie",
-    "Connection Error": "Eroare de conexiune",
-    "Copied from elsewhere": "Copiat din altă parte",
-    "Copied from original": "Copiat  din original",
-    "Copyright © 2015 the following Contributors:": "Copyright ©2015 Următorii Contribuitori:",
-    "Delete": "Şterge",
-    "Deleted": "Deleted",
-    "Device ID": "ID Dispozitiv",
-    "Device Identification": "Identificare Dispozitiv",
-    "Device Name": "Nume Dispozitiv",
-    "Device {%device%} ({%address%}) wants to connect. Add new device?": "Dispozitivul{{dispoztiv}}({{adresă}})vrea sa se conecteze.Adaug un dispozitiv nou?",
-    "Devices": "Dispozitiv",
-    "Disconnected": "Deconectat",
-    "Documentation": "Documentaţie",
-    "Download Rate": "Viteză de Descărcare",
-    "Downloaded": "Descărcat",
-    "Downloading": "Se descarcă",
-    "Edit": "Modifică",
-    "Edit Device": "Modifică Dispozitiv",
-    "Edit Folder": "Modifică Mapa",
-    "Editing": "Modificare",
-    "Enable UPnP": "Activează UPnP",
-    "Enter comma separated \"ip:port\" addresses or \"dynamic\" to perform automatic discovery of the address.": "Adaugă, separate prin virgulă, adresele IP \"ip:port\" sau \"dynamic\" (dinamic) pentru ca adresele să fie descoperite automat.",
-    "Enter ignore patterns, one per line.": "Adaugă șabloanele de ignorare, câte una pe linie.",
-    "Error": "Eroare",
-    "External File Versioning": "Administrare externă a versiunilor documentului",
-    "Failed Items": "Failed Items",
-    "File Pull Order": "File Pull Order",
-    "File Versioning": "Versiune Fișier",
-    "File permission bits are ignored when looking for changes. Use on FAT file systems.": "Biții de autorizare sînt excluși cînd se analizează modificările. A se utiliza pe sisteme FAT. ",
-    "Files are moved to .stversions folder when replaced or deleted by Syncthing.": "Files are moved to .stversions folder when replaced or deleted by Syncthing.",
-    "Files are moved to date stamped versions in a .stversions folder when replaced or deleted by Syncthing.": "Documentele sînt mutate într-un fișier .stversions conținînd versiuni datate atunci cînd sînt șterse sau înlocuite de Syncthing. ",
-    "Files are protected from changes made on other devices, but changes made on this device will be sent to the rest of the cluster.": "Fișierele sunt protejate de schimbările făcute pe alte dispozitive dar schimbările efectuate pe acest dispozitiv vor fi trimise catre restul grupului.",
-    "Folder": "Folder",
-    "Folder ID": "ID Mapă",
-    "Folder Master": "Master Măpi",
-    "Folder Path": "Locaţie Mapei",
-    "Folders": "Mapă",
-    "GUI": "GUI",
-    "GUI Authentication Password": "Parolă Interfaţă",
-    "GUI Authentication User": "User Interfaţă",
-    "GUI Listen Addresses": "Adresă Interfaţă",
-    "Generate": "Generează",
-    "Global Discovery": "Găsire Globală",
-    "Global Discovery Server": "Server pentru Găsirea Globală",
-    "Global State": "Status Global",
-    "Help": "Help",
-    "Home page": "Home page",
-    "Ignore": "Ignoră",
-    "Ignore Patterns": "Reguli de excludere",
-    "Ignore Permissions": "Ignoră Permisiuni",
-    "Incoming Rate Limit (KiB/s)": "Limită Viteză de Download (KB/s)",
-    "Incorrect configuration may damage your folder contents and render Syncthing inoperable.": "Incorrect configuration may damage your folder contents and render Syncthing inoperable.",
-    "Introducer": "Dispozitiv Inițiator",
-    "Inversion of the given condition (i.e. do not exclude)": "Inversarea condiției (de ex., nu exclude)",
-    "Keep Versions": "Păstrează Versiuni",
-    "Largest First": "Largest First",
-    "Last File Received": "Ultimul Fișier Primit",
-    "Last seen": "Ultima vizionare",
-    "Later": "Mai tîrziu",
-    "Local Discovery": "Găsire Locală",
-    "Local State": "Status Local",
-    "Local State (Total)": "Local State (Total)",
-    "Major Upgrade": "Major Upgrade",
-    "Maximum Age": "Vârsta Maximă",
-    "Metadata Only": "Doar Metadate",
-    "Minimum Free Disk Space": "Minimum Free Disk Space",
-    "Move to top of queue": "Mută la începutul listei",
-    "Multi level wildcard (matches multiple directory levels)": "Asterisc de nivel multiplu (corespunde fișierelor și sub-fișierelor)",
-    "Never": "Niciodată",
-    "New Device": "Dispozitiv Nou",
-    "New Folder": "Mapă Nouă",
-    "Newest First": "Newest First",
-    "No": "Nu",
-    "No File Versioning": "Fără versiuni ale documentelor",
-    "Notice": "Mențiuni",
-    "OK": "OK",
-    "Off": "Închis",
-    "Oldest First": "Oldest First",
-    "Options": "Options",
-    "Out of Sync": "Out of Sync",
-    "Out of Sync Items": "Elemente Nesincronizate",
-    "Outgoing Rate Limit (KiB/s)": "Limită Viteză de Upload (KB/s)",
-    "Override Changes": "Suprascrie Schimbări",
-    "Path to the folder on the local computer. Will be created if it does not exist. The tilde character (~) can be used as a shortcut for": "Localizarea fișierului în acest computer. Dacă nu există, va fi creat. Tilda (~) înlocuiește ",
-    "Path where versions should be stored (leave empty for the default .stversions folder in the folder).": "Locul unde vor fi stocate versiunile (a se lăsa neschimbat pentru fișierul .stversions din fișier). ",
-    "Please consult the release notes before performing a major upgrade.": "Please consult the release notes before performing a major upgrade.",
-    "Please wait": "Aşteaptă",
-    "Preview": "Previzualizează",
-    "Preview Usage Report": "Vezi raportul de utilizare",
-    "Quick guide to supported patterns": "Ghid rapid pentru regulile suportate",
-    "RAM Utilization": "RAM",
-    "Random": "Random",
-    "Release Notes": "Release Notes",
-    "Remove": "Remove",
-    "Rescan": "Rescanează",
-    "Rescan All": "Rescaneaza Tot",
-    "Rescan Interval": "Interval Scanare",
-    "Restart": "Restart",
-    "Restart Needed": "Restart Necesar",
-    "Restarting": "Se restartează",
-    "Reused": "Refolosit",
-    "Save": "Salvează",
-    "Scanning": "Scanează",
-    "Select the devices to share this folder with.": "Selectează dispozitivele pentru care să fie disponibil această mapă.",
-    "Select the folders to share with this device.": "Alege mapele pe care vrei sa le imparți cu acest dispozitiv.",
-    "Settings": "Setări",
-    "Share": "Împarte",
-    "Share Folder": "Împarte Mapa",
-    "Share Folders With Device": "Împarte Mapa Cu Dispozitivul",
-    "Share With Devices": "Împarte Cu Dispozitivul",
-    "Share this folder?": "Împarte această mapă?",
-    "Shared With": "Împarte Cu",
-    "Short identifier for the folder. Must be the same on all cluster devices.": "Identificator scurt al fișierului. Trebuie să fie același pe toate mașinile. ",
-    "Show ID": "Arată ID",
-    "Shown instead of Device ID in the cluster status. Will be advertised to other devices as an optional default name.": "Vizibil în locul ID-ului dispozitivului într-un grup. Va fi sugerat celorlalte dispozitive ca nume opţional. ",
-    "Shown instead of Device ID in the cluster status. Will be updated to the name the device advertises if left empty.": "Vizibil în locul ID-ului dispozitivului într-un grup. Va fi înlocuit de numele sugerat de dispozitiv daca nu este completat. ",
-    "Shutdown": "Opreşte",
-    "Shutdown Complete": "Oprește Complet",
-    "Simple File Versioning": "Versiuni simple ale documentelor",
-    "Single level wildcard (matches within a directory only)": "Asterisc de nivel simplu (corespunde doar unui fişier)",
-    "Smallest First": "Smallest First",
-    "Source Code": "Cod Sursă",
-    "Staggered File Versioning": "Versiuni eşalonate ale documentelor",
-    "Start Browser": "Lansează Browser",
-    "Statistics": "Statistics",
-    "Stopped": "Oprit",
-    "Support": "Suport Tehnic",
-    "Sync Protocol Listen Addresses": "Adresa protocolului de sincronizare",
-    "Syncing": "Se sincronizează",
-    "Syncthing has been shut down.": "Sincronizarea a fost oprită.",
-    "Syncthing includes the following software or portions thereof:": "Syncthing include următoarele soft-uri sau părţi din ele:",
-    "Syncthing is restarting.": "Syncthing se restartează.",
-    "Syncthing is upgrading.": "Syncthing se actualizează.",
-    "Syncthing seems to be down, or there is a problem with your Internet connection. Retrying…": "Syncthing pare a fi oprit sau aveţi probleme cu conexiunea la internet. Reluare... ",
-    "Syncthing seems to be experiencing a problem processing your request. Please refresh the page or restart Syncthing if the problem persists.": "Syncthing pare a avea probleme prelucrînd solicitarea dumneavoastră. Reîncărcaţi pagina sau porniţi Syncthing din nou dacă problema continuă. ",
-    "The aggregated statistics are publicly available at {%url%}.": "Statisticile în ansamblu sînt accesibile public la {{url}}.",
-    "The configuration has been saved but not activated. Syncthing must restart to activate the new configuration.": "Configuraţia a fost salvată dar nu şi activată. Syncthing trebuie să repornească pentru a activa noua configuraţie.",
-    "The device ID cannot be blank.": "ID-ul dispozitivului nu poate fi gol.",
-    "The device ID to enter here can be found in the \"Edit > Show ID\" dialog on the other device. Spaces and dashes are optional (ignored).": "ID-ul dispozitivului ce trebuie introdus aici poate fi aflat la \"Editează > Arată ID-ul\" pe celălalt dispozitiv. Spaţiile şi liniile oblice sînt opţionale (vor fi ignorate). ",
-    "The encrypted usage report is sent daily. It is used to track common platforms, folder sizes and app versions. If the reported data set is changed you will be prompted with this dialog again.": "Raportul codat de utilizare este trimit zilnic. Este folosit pentru studierea platformelor comune, dimensiunilor fişierelor şi versiunea aplicaţiilor. În cazul în care setul de date trimis este modificat, acest dialog va aparea din nou. ",
-    "The entered device ID does not look valid. It should be a 52 or 56 character string consisting of letters and numbers, with spaces and dashes being optional.": "ID-ul dispozitivului nu pare a fi valid.El trebuie sa fie format dintrun șir din 52 ori 56 de caractere formate din litere și cifre, cu spatii și linii opțional.",
-    "The first command line parameter is the folder path and the second parameter is the relative path in the folder.": "The first command line parameter is the folder path and the second parameter is the relative path in the folder.",
-    "The folder ID cannot be blank.": "ID-ul mapei nu poate fi gol.",
-    "The folder ID must be a short identifier (64 characters or less) consisting of letters, numbers and the dot (.), dash (-) and underscode (_) characters only.": "The folder ID must be a short identifier (64 characters or less) consisting of letters, numbers and the dot (.), dash (-) and underscode (_) characters only.",
-    "The folder ID must be unique.": "ID-ul mapei trebuie să fie unic.",
-    "The folder path cannot be blank.": "Locaţia mapei nu poate fi goală.",
-    "The following intervals are used: for the first hour a version is kept every 30 seconds, for the first day a version is kept every hour, for the first 30 days a version is kept every day, until the maximum age a version is kept every week.": "The following intervals are used: for the first hour a version is kept every 30 seconds, for the first day a version is kept every hour, for the first 30 days a version is kept every day, until the maximum age a version is kept every week.",
-    "The following items could not be synchronized.": "The following items could not be synchronized.",
-    "The maximum age must be a number and cannot be blank.": "Vârsta maximă trebuie să fie un număr şi nu poate fi goală.",
-    "The maximum time to keep a version (in days, set to 0 to keep versions forever).": "Câte zile să se păstreze o versiune (setează 0 pentru nelimitat)",
-    "The minimum free disk space percentage must be a non-negative number between 0 and 100 (inclusive).": "The minimum free disk space percentage must be a non-negative number between 0 and 100 (inclusive).",
-    "The number of days must be a number and cannot be blank.": "The number of days must be a number and cannot be blank.",
-    "The number of days to keep files in the trash can. Zero means forever.": "The number of days to keep files in the trash can. Zero means forever.",
-    "The number of old versions to keep, per file.": "Numărul de versiuni vechi de salvat per fişier.",
-    "The number of versions must be a number and cannot be blank.": "Numărul de versiuni trebuie să fie un număr şi nu poate fi gol.",
-    "The path cannot be blank.": "Locația nu poate fi goală.",
-    "The rate limit must be a non-negative number (0: no limit)": "The rate limit must be a non-negative number (0: no limit)",
-    "The rescan interval must be a non-negative number of seconds.": "Intervalul de rescanare trebuie să nu fie un număr negativ de secunde. ",
-    "They are retried automatically and will be synced when the error is resolved.": "They are retried automatically and will be synced when the error is resolved.",
-    "This is a major version upgrade.": "This is a major version upgrade.",
-    "Trash Can File Versioning": "Trash Can File Versioning",
-    "Unknown": "Necunoscut",
-    "Unshared": "Neîmpărțit",
-    "Unused": "Nefolosit",
-    "Up to Date": "La Zi",
-    "Updated": "Updated",
-    "Upgrade": "Upgrade",
-    "Upgrade To {%version%}": "Actualizează La Versiunea {{version}}",
-    "Upgrading": "Se Actualizează",
-    "Upload Rate": "Viteză Upload",
-    "Uptime": "Uptime",
-    "Use HTTPS for GUI": "Foloseşte HTTPS pentru interfaţă",
-    "Version": "Versiune",
-    "Versions Path": "Locaţie Versiuni",
-    "Versions are automatically deleted if they are older than the maximum age or exceed the number of files allowed in an interval.": "Versiunile sînt şterse în mod automat dacă sînt mai vechi decît vîrsta maximă sau depăşesc numărul de documente permise într-un anume interval. ",
-    "When adding a new device, keep in mind that this device must be added on the other side too.": "Când adaugi un dispozitiv nou, trebuie să adaugi şi dispozitivul curent în dispozitivul nou.",
-    "When adding a new folder, keep in mind that the Folder ID is used to tie folders together between devices. They are case sensitive and must match exactly between all devices.": "Cînd adăugaţi un fişier nou, nu uitaţi că ID-ul fişierului va rămîne acelaşi pe toate dispozitivele. Iar literele mari sînt diferite de literele mici. ",
-    "Yes": "Da",
-    "You must keep at least one version.": "Trebuie să păstrezi cel puţin o versiune.",
-    "full documentation": "toată documentaţia",
-    "items": "obiecte",
-    "{%device%} wants to share folder \"{%folder%}\".": "{{Dispozitivul}} vrea să transmită mapa {{Mapa}}"
-}