Merge pull request #636 from jbenet/cleanup-logs

Cleanup logs

Godeps/Godeps.json

@@ -60,6 +60,10 @@
 			"ImportPath": "github.com/bren2010/proquint",
 			"Rev": "5958552242606512f714d2e93513b380f43f9991"
 		},
+		{
+			"ImportPath": "github.com/briantigerchow/inflect",
+			"Rev": "cef1f9cc2234281dc58ea10be7e9aad5e282ecab"
+		},
 		{
 			"ImportPath": "github.com/camlistore/lock",
 			"Rev": "ae27720f340952636b826119b58130b9c1a847a0"

Godeps/_workspace/src/github.com/briantigerchow/inflect/.gitignore

+.DS_Store

Godeps/_workspace/src/github.com/briantigerchow/inflect/README.md

+# inflect
+
+Inflections made easy for Go.
+
+[![Build Status](https://drone.io/github.com/chuckpreslar/inflect/status.png)](https://drone.io/github.com/chuckpreslar/inflect/latest)
+
+## Installation
+
+With Google's [Go](http://www.golang.org) installed on your machine:
+
+    $ go get -u github.com/chuckpreslar/inflect
+
+## Usage
+
+```go
+import (
+  "github.com/chuckpreslar/inflect"
+)
+
+func main() {
+  inflect.Pluralize("user") // users
+  inflect.Pluralize("knife") // knives
+  
+  inflect.Singularize("orders") // order
+  
+  inflect.UpperCamelCase("this_is_underscored_mixedCased-And-Hyphenated") // ThisIsUnderscoredMixedCasedAndHyphenated
+}
+```
+
+## Support
+
+* Pluralization and singularization of words with proper language rules.
+* Case transformation from and to upper camel casing, lower camel casing, underscoring, hyphenating, and constantization.
+
+## Documentation
+
+View godoc or visit [godoc.org](http://godoc.org/github.com/chuckpreslar/inflect).
+
+    $ godoc inflect
+
+## License
+
+> The MIT License (MIT)
+
+> Copyright (c) 2013 Chuck Preslar
+
+> Permission is hereby granted, free of charge, to any person obtaining a copy
+> of this software and associated documentation files (the "Software"), to deal
+> in the Software without restriction, including without limitation the rights
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the Software is
+> furnished to do so, subject to the following conditions:
+
+> The above copyright notice and this permission notice shall be included in
+> all copies or substantial portions of the Software.
+
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+> THE SOFTWARE.

Godeps/_workspace/src/github.com/briantigerchow/inflect/inflect.go

+// Package inflect provides an inflector.
+package inflect
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+)
+
+func Pluralize(str string) string {
+	if inflector, ok := Languages[Language]; ok {
+		return inflector.Pluralize(str)
+	}
+
+	return str
+}
+
+func Singularize(str string) string {
+	if inflector, ok := Languages[Language]; ok {
+		return inflector.Singularize(str)
+	}
+
+	return str
+}
+
+func FromNumber(str string, n int) string {
+	switch n {
+	case 1:
+		return Singularize(str)
+	default:
+		return Pluralize(str)
+	}
+}
+
+// Split's a string so that it can be converted to a different casing.
+// Splits on underscores, hyphens, spaces and camel casing.
+func split(str string) []string {
+	// FIXME: This isn't a perfect solution.
+	// ex. WEiRD CaSINg (Support for 13 year old developers)
+	return strings.Split(regexp.MustCompile(`-|_|([a-z])([A-Z])`).ReplaceAllString(strings.Trim(str, `-|_| `), `$1 $2`), ` `)
+}
+
+// UpperCamelCase converts a string to it's upper camel case version.
+func UpperCamelCase(str string) string {
+	pieces := split(str)
+
+	for index, s := range pieces {
+		pieces[index] = fmt.Sprintf(`%v%v`, strings.ToUpper(string(s[0])), strings.ToLower(s[1:]))
+	}
+
+	return strings.Join(pieces, ``)
+}
+
+// LowerCamelCase converts a string to it's lower camel case version.
+func LowerCamelCase(str string) string {
+	pieces := split(str)
+
+	pieces[0] = strings.ToLower(pieces[0])
+
+	for i := 1; i < len(pieces); i++ {
+		pieces[i] = fmt.Sprintf(`%v%v`, strings.ToUpper(string(pieces[i][0])), strings.ToLower(pieces[i][1:]))
+	}
+
+	return strings.Join(pieces, ``)
+}
+
+// Underscore converts a string to it's underscored version.
+func Underscore(str string) string {
+	pieces := split(str)
+
+	for index, piece := range pieces {
+		pieces[index] = strings.ToLower(piece)
+	}
+
+	return strings.Join(pieces, `_`)
+}
+
+// Hyphenate converts a string to it's hyphenated version.
+func Hyphenate(str string) string {
+	pieces := split(str)
+
+	for index, piece := range pieces {
+		pieces[index] = strings.ToLower(piece)
+	}
+
+	return strings.Join(pieces, `-`)
+}
+
+// Constantize converts a string to it's constantized version.
+func Constantize(str string) string {
+	pieces := split(str)
+
+	for index, piece := range pieces {
+		pieces[index] = strings.ToUpper(piece)
+	}
+
+	return strings.Join(pieces, `_`)
+}
+
+// Humanize converts a string to it's humanized version.
+func Humanize(str string) string {
+	pieces := split(str)
+
+	pieces[0] = fmt.Sprintf(`%v%v`, strings.ToUpper(string(pieces[0][0])), strings.ToLower(pieces[0][1:]))
+
+	for i := 1; i < len(pieces); i++ {
+		pieces[i] = fmt.Sprintf(`%v`, strings.ToLower(pieces[i]))
+	}
+
+	return strings.Join(pieces, ` `)
+}
+
+// Titleize converts a string to it's titleized version.
+func Titleize(str string) string {
+	pieces := split(str)
+
+	for i := 0; i < len(pieces); i++ {
+		pieces[i] = fmt.Sprintf(`%v%v`, strings.ToUpper(string(pieces[i][0])), strings.ToLower(pieces[i][1:]))
+	}
+
+	return strings.Join(pieces, ` `)
+}

Godeps/_workspace/src/github.com/briantigerchow/inflect/inflect_test.go

+package inflect
+
+import (
+	"testing"
+)
+
+func TestPluralize(t *testing.T) {
+	tests := []string{"half", "potato", "cello", "disco", "chef", "wife", "poppy", "sty", "football", "tester", "play", "hero", "tooth", "mouse", "goose", "person", "foot", "money", "monkey", "calf", "lie", "auto", "studio"}
+	results := []string{"halves", "potatoes", "cellos", "discos", "chefs", "wives", "poppies", "sties", "footballs", "testers", "plays", "heroes", "teeth", "mice", "geese", "people", "feet", "money", "monkeys", "calves", "lies", "autos", "studios"}
+
+	for index, test := range tests {
+		if result := Pluralize(test); result != results[index] {
+			t.Errorf("Expected %v, got %v", results[index], result)
+		}
+	}
+}
+
+func TestCommonPluralize(t *testing.T) {
+	tests := []string{"user", "order", "product", "verse", "test", "upload", "class", "course", "game", "score", "body", "life", "dice"}
+	results := []string{"users", "orders", "products", "verses", "tests", "uploads", "classes", "courses", "games", "scores", "bodies", "lives", "die"}
+
+	for index, test := range tests {
+		if result := Pluralize(test); result != results[index] {
+			t.Errorf("Expected %v, got %v", results[index], result)
+		}
+	}
+}
+
+func TestSingularization(t *testing.T) {
+	tests := []string{"halves", "potatoes", "cellos", "discos", "chefs", "wives", "poppies", "sties", "footballs", "testers", "plays", "heroes", "teeth", "mice", "geese", "people", "feet", "money", "monkeys", "calves", "lies", "autos", "studios"}
+	results := []string{"half", "potato", "cello", "disco", "chef", "wife", "poppy", "sty", "football", "tester", "play", "hero", "tooth", "mouse", "goose", "person", "foot", "money", "monkey", "calf", "lie", "auto", "studio"}
+
+	for index, test := range tests {
+		if result := Singularize(test); result != results[index] {
+			t.Errorf("Expected %v, got %v", results[index], result)
+		}
+	}
+}
+
+func TestCommonSingularization(t *testing.T) {
+	tests := []string{"users", "orders", "products", "verses", "tests", "uploads", "classes", "courses", "games", "scores", "bodies", "lives", "die"}
+	results := []string{"user", "order", "product", "verse", "test", "upload", "class", "course", "game", "score", "body", "life", "dice"}
+
+	for index, test := range tests {
+		if result := Singularize(test); result != results[index] {
+			t.Errorf("Expected %v, got %v", results[index], result)
+		}
+	}
+}
+
+func TestUpperCamelCase(t *testing.T) {
+	tests := []string{"_pre", "post_", "    spaced", "single", "lowerCamelCase", "under_scored", "hyphen-ated", "UpperCamelCase", "spaced Out"}
+	results := []string{"Pre", "Post", "Spaced", "Single", "LowerCamelCase", "UnderScored", "HyphenAted", "UpperCamelCase", "SpacedOut"}
+
+	for index, test := range tests {
+		if result := UpperCamelCase(test); result != results[index] {
+			t.Errorf("Expected %v, got %v", results[index], result)
+		}
+	}
+}
+
+func TestLowerCamelCase(t *testing.T) {
+	tests := []string{"single", "lowerCamelCase", "under_scored", "hyphen-ated", "UpperCamelCase", "spaced Out"}
+	results := []string{"single", "lowerCamelCase", "underScored", "hyphenAted", "upperCamelCase", "spacedOut"}
+
+	for index, test := range tests {
+		if result := LowerCamelCase(test); result != results[index] {
+			t.Errorf("Expected %v, got %v", results[index], result)
+		}
+	}
+}
+
+func TestUnderscore(t *testing.T) {
+	tests := []string{"single", "lowerCamelCase", "under_scored", "hyphen-ated", "UpperCamelCase", "spaced Out"}
+	results := []string{"single", "lower_camel_case", "under_scored", "hyphen_ated", "upper_camel_case", "spaced_out"}
+
+	for index, test := range tests {
+		if result := Underscore(test); result != results[index] {
+			t.Errorf("Expected %v, got %v", results[index], result)
+		}
+	}
+}
+
+func TestHyphenate(t *testing.T) {
+	tests := []string{"single", "lowerCamelCase", "under_scored", "hyphen-ated", "UpperCamelCase", "spaced Out"}
+	results := []string{"single", "lower-camel-case", "under-scored", "hyphen-ated", "upper-camel-case", "spaced-out"}
+
+	for index, test := range tests {
+		if result := Hyphenate(test); result != results[index] {
+			t.Errorf("Expected %v, got %v", results[index], result)
+		}
+	}
+}
+
+func TestConstantize(t *testing.T) {
+	tests := []string{"single", "lowerCamelCase", "under_scored", "hyphen-ated", "UpperCamelCase", "spaced Out"}
+	results := []string{"SINGLE", "LOWER_CAMEL_CASE", "UNDER_SCORED", "HYPHEN_ATED", "UPPER_CAMEL_CASE", "SPACED_OUT"}
+
+	for index, test := range tests {
+		if result := Constantize(test); result != results[index] {
+			t.Errorf("Expected %v, got %v", results[index], result)
+		}
+	}
+}
+
+func TestHumanize(t *testing.T) {
+	tests := []string{"single", "lowerCamelCase", "under_scored", "hyphen-ated", "UpperCamelCase", "spaced Out"}
+	results := []string{"Single", "Lower camel case", "Under scored", "Hyphen ated", "Upper camel case", "Spaced out"}
+
+	for index, test := range tests {
+		if result := Humanize(test); result != results[index] {
+			t.Errorf("Expected %v, got %v", results[index], result)
+		}
+	}
+}
+
+func TestTitleize(t *testing.T) {
+	tests := []string{"single", "lowerCamelCase", "under_scored", "hyphen-ated", "UpperCamelCase", "spaced Out"}
+	results := []string{"Single", "Lower Camel Case", "Under Scored", "Hyphen Ated", "Upper Camel Case", "Spaced Out"}
+
+	for index, test := range tests {
+		if result := Titleize(test); result != results[index] {
+			t.Errorf("Expected %v, got %v", results[index], result)
+		}
+	}
+}

Godeps/_workspace/src/github.com/briantigerchow/inflect/languages.go

+// Package inflect provides an inflector.
+package inflect
+
+import (
+	"github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/briantigerchow/inflect/languages"
+	"github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/briantigerchow/inflect/types"
+)
+
+var (
+	// Language to use when converting a word from it's plural to
+	// singular forms and vice versa.
+	Language = "en"
+
+	// Languages avaiable for converting a word from
+	// it's plural to singular forms and vice versa.
+	Languages = map[string]*types.LanguageType{
+		"en": languages.English,
+	}
+)

Godeps/_workspace/src/github.com/briantigerchow/inflect/languages/english.go

+// Package languages provides language rules to use with the inflect package.
+package languages
+
+import (
+	"github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/briantigerchow/inflect/types"
+)
+
+// Defines irregular words, uncountables words, and pluralization/singularization rules for the English language.
+//
+// FIXME: Singular/Plural rules could be better, I went to school for engineering, not English.
+var English = types.Language("en").
+	// Pluralization rules.
+	Plural(`(auto)$`, `${1}s`).
+	Plural(`(s|ss|sh|ch|x|to|ro|ho|jo)$`, `${1}es`).
+	Plural(`(i)fe$`, `${1}ves`).
+	Plural(`(t|f|g)oo(th|se|t)$`, `${1}ee${2}`).
+	Plural(`(a|e|i|o|u)y$`, `${1}ys`).
+	Plural(`(m|l)ouse$`, `${1}ice`).
+	Plural(`(al|ie|l)f$`, `${1}ves`).
+	Plural(`(d)ice`, `${1}ie`).
+	Plural(`y$`, `ies`).
+	Plural(`$`, `s`).
+	// Singularization rules.
+	Singular(`(auto)s$`, `${1}`).
+	Singular(`(rse)s$`, `${1}`).
+	Singular(`(s|ss|sh|ch|x|to|ro|ho|jo)es$`, `${1}`).
+	Singular(`(i)ves$`, `${1}fe`).
+	Singular(`(t|f|g)ee(th|se|t)$`, `${1}oo${2}`).
+	Singular(`(a|e|i|o|u)ys$`, `${1}y`).
+	Singular(`(m|l)ice$`, `${1}ouse`).
+	Singular(`(al|ie|l)ves$`, `${1}f`).
+	Singular(`(l)ies`, `${1}ie`).
+	Singular(`ies$`, `y`).
+	Singular(`(d)ie`, `${1}ice`).
+	Singular(`s$`, ``).
+	// Irregulars words.
+	Irregular(`person`, `people`).
+	Irregular(`child`, `children`).
+	// Uncountables words.
+	Uncountable(`fish`).
+	Uncountable(`sheep`).
+	Uncountable(`deer`).
+	Uncountable(`tuna`).
+	Uncountable(`salmon`).
+	Uncountable(`trout`).
+	Uncountable(`music`).
+	Uncountable(`art`).
+	Uncountable(`love`).
+	Uncountable(`happiness`).
+	Uncountable(`advice`).
+	Uncountable(`information`).
+	Uncountable(`news`).
+	Uncountable(`furniture`).
+	Uncountable(`luggage`).
+	Uncountable(`rice`).
+	Uncountable(`sugar`).
+	Uncountable(`butter`).
+	Uncountable(`water`).
+	Uncountable(`electricity`).
+	Uncountable(`gas`).
+	Uncountable(`power`).
+	Uncountable(`money`).
+	Uncountable(`currency`).
+	Uncountable(`scenery`)

Godeps/_workspace/src/github.com/briantigerchow/inflect/types/irregular.go

+// Package types contains common types useful to the inflect package.
+package types
+
+import "strings"
+
+// IrregularType provides a structure for irregular words that do not follow standard rules.
+type IrregularType struct {
+	Singular string // The singular form of the irregular word.
+	Plural   string // The plural form of the irregular word.
+}
+
+// IrregularsType defines a slice of pointers to IrregularType.
+type IrregularsType []*IrregularType
+
+// IsIrregular returns an IrregularType and bool if the IrregularsType slice contains the word.
+func (self IrregularsType) IsIrregular(str string) (*IrregularType, bool) {
+	str = strings.ToLower(str)
+	for _, irregular := range self {
+		if strings.ToLower(irregular.Singular) == str || strings.ToLower(irregular.Plural) == str {
+			return irregular, true
+		}
+	}
+
+	return nil, false
+}
+
+// Irregular if a factory method to a new IrregularType.
+func Irregular(singular, plural string) (irregular *IrregularType) {
+	irregular = new(IrregularType)
+	irregular.Singular = singular
+	irregular.Plural = plural
+
+	return
+}

Godeps/_workspace/src/github.com/briantigerchow/inflect/types/language.go

+// Package types contains common types useful to the inflect package.
+package types
+
+// LanguageType provides a structure for storing inflections rules of a language.
+type LanguageType struct {
+	Short            string           // The short hand form represention the language, ex. `en` (English).
+	Pluralizations   RulesType        // Rules for pluralizing standard words.
+	Singularizations RulesType        // Rules for singularizing standard words.
+	Irregulars       IrregularsType   // Slice containing irregular words that do not follow standard rules.
+	Uncountables     UncountablesType // Words that are uncountable, having the same form for both singular and plural.
+}
+
+func convert(str, form string, language *LanguageType, rules RulesType) string {
+	if language.Uncountables.Contains(str) {
+		return str
+	} else if irregular, ok := language.Irregulars.IsIrregular(str); ok {
+		if form == "singular" {
+			return irregular.Singular
+		}
+		return irregular.Plural
+	} else {
+		for _, rule := range rules {
+			if rule.Regexp.MatchString(str) {
+				return rule.Regexp.ReplaceAllString(str, rule.Replacer)
+			}
+		}
+	}
+
+	return str
+}
+
+// Pluralize converts the given string to the languages plural form.
+func (self *LanguageType) Pluralize(str string) string {
+	return convert(str, "plural", self, self.Pluralizations)
+}
+
+// Singularize converts the given string to the languages singular form.
+func (self *LanguageType) Singularize(str string) string {
+	return convert(str, "singular", self, self.Singularizations)
+}
+
+// Plural defines a pluralization rule for a language.
+func (self *LanguageType) Plural(matcher, replacer string) *LanguageType {
+	self.Pluralizations = append(self.Pluralizations, Rule(matcher, replacer))
+
+	return self
+}
+
+// Plural defines a singularization rule for a language.
+func (self *LanguageType) Singular(matcher, replacer string) *LanguageType {
+	self.Singularizations = append(self.Singularizations, Rule(matcher, replacer))
+
+	return self
+}
+
+// Plural defines an irregular word for a langauge.
+func (self *LanguageType) Irregular(singular, plural string) *LanguageType {
+	self.Irregulars = append(self.Irregulars, Irregular(singular, plural))
+
+	return self
+}
+
+// Plural defines an uncountable word for a langauge.
+func (self *LanguageType) Uncountable(uncountable string) *LanguageType {
+	self.Uncountables = append(self.Uncountables, uncountable)
+
+	return self
+}
+
+// Language if a factory method to a new LanguageType.
+func Language(short string) (language *LanguageType) {
+	language = new(LanguageType)
+
+	language.Pluralizations = make(RulesType, 0)
+	language.Singularizations = make(RulesType, 0)
+	language.Irregulars = make(IrregularsType, 0)
+	language.Uncountables = make(UncountablesType, 0)
+
+	return
+}

Godeps/_workspace/src/github.com/briantigerchow/inflect/types/rule.go

+// Package types contains common types useful to the inflect package.
+package types
+
+import (
+	"regexp"
+)
+
+// RuleType provides a structure for pluralization/singularizations rules
+// of a language.
+type RuleType struct {
+	Regexp   *regexp.Regexp // The regular expression the rule must match.
+	Replacer string         // The replacement to use if the RuleType's Regexp is matched.
+}
+
+// RulesType defines a slice of pointers to RuleType.
+type RulesType []*RuleType
+
+// Rule if a factory method to a new RuleType.
+func Rule(matcher, replacer string) (rule *RuleType) {
+	rule = new(RuleType)
+	rule.Regexp = regexp.MustCompile(matcher)
+	rule.Replacer = replacer
+
+	return
+}

Godeps/_workspace/src/github.com/briantigerchow/inflect/types/uncountable.go

+// Package types contains common types useful to the inflect package.
+package types
+
+// UncountablesType is an array of strings
+type UncountablesType []string
+
+// Contains returns a bool if the str is found in the UncountablesType.
+func (self UncountablesType) Contains(str string) bool {
+	for _, word := range self {
+		if word == str {
+			return true
+		}
+	}
+
+	return false
+}

cmd/ipfs/main.go

@@ -24,7 +24,6 @@ import (
 	config "github.com/jbenet/go-ipfs/repo/config"
 	fsrepo "github.com/jbenet/go-ipfs/repo/fsrepo"
 	eventlog "github.com/jbenet/go-ipfs/thirdparty/eventlog"
-	updates "github.com/jbenet/go-ipfs/updates"
 	u "github.com/jbenet/go-ipfs/util"
 	"github.com/jbenet/go-ipfs/util/debugerror"
 )
@@ -265,33 +264,11 @@ func callPreCommandHooks(ctx context.Context, details cmdDetails, req cmds.Reque
 	log.Event(ctx, "callPreCommandHooks", &details)
 	log.Debug("Calling pre-command hooks...")
 
-	// some hooks only run when the command is executed locally
-	daemon, err := commandShouldRunOnDaemon(details, req, root)
-	if err != nil {
-		return err
-	}
-
-	// check for updates when 1) commands is going to be run locally, 2) the
-	// command does not initialize the config, and 3) the command does not
-	// pre-empt updates
-	if !daemon && details.usesConfigAsInput() && details.doesNotPreemptAutoUpdate() {
-
-		log.Debug("Calling hook: Check for updates")
-
-		cfg, err := req.Context().GetConfig()
-		if err != nil {
-			return err
-		}
-		// Check for updates and potentially install one.
-		if err := updates.CliCheckForUpdates(cfg, req.Context().ConfigRoot); err != nil {
-			return err
-		}
-	}
-
 	return nil
 }
 
 func callCommand(ctx context.Context, req cmds.Request, root *cmds.Command, cmd *cmds.Command) (cmds.Response, error) {
+	log.Info(config.EnvDir, req.Context().ConfigRoot)
 	var res cmds.Response
 
 	details, err := commandDetails(req.Path(), root)

exchange/bitswap/bitswap.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
+	inflect "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/briantigerchow/inflect"
 
 	blocks "github.com/jbenet/go-ipfs/blocks"
 	blockstore "github.com/jbenet/go-ipfs/blocks/blockstore"
@@ -169,20 +170,14 @@ func (bs *bitswap) HasBlock(ctx context.Context, blk *blocks.Block) error {
 }
 
 func (bs *bitswap) sendWantlistMsgToPeers(ctx context.Context, m bsmsg.BitSwapMessage, peers <-chan peer.ID) error {
-	if peers == nil {
-		panic("Cant send wantlist to nil peerchan")
-	}
-
 	set := pset.New()
 	wg := sync.WaitGroup{}
 	for peerToQuery := range peers {
 		log.Event(ctx, "PeerToQuery", peerToQuery)
 
 		if !set.TryAdd(peerToQuery) { //Do once per peer
-			log.Debugf("%s skipped (already sent)", peerToQuery)
 			continue
 		}
-		log.Debugf("%s sending", peerToQuery)
 
 		wg.Add(1)
 		go func(p peer.ID) {
@@ -205,12 +200,7 @@ func (bs *bitswap) sendWantlistToPeers(ctx context.Context, peers <-chan peer.ID
 	return bs.sendWantlistMsgToPeers(ctx, message, peers)
 }
 
-func (bs *bitswap) sendWantlistToProviders(ctx context.Context) {
-	entries := bs.wantlist.Entries()
-	if len(entries) == 0 {
-		log.Debug("No entries in wantlist, skipping send routine.")
-		return
-	}
+func (bs *bitswap) sendWantlistToProviders(ctx context.Context, entries []wantlist.Entry) {
 
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
@@ -228,7 +218,6 @@ func (bs *bitswap) sendWantlistToProviders(ctx context.Context) {
 			child, _ := context.WithTimeout(ctx, providerRequestTimeout)
 			providers := bs.network.FindProvidersAsync(child, k, maxProvidersPerRequest)
 			for prov := range providers {
-				log.Debugf("dht returned provider %s. send wantlist", prov)
 				sendToPeers <- prov
 			}
 		}(e.Key)
@@ -249,7 +238,6 @@ func (bs *bitswap) taskWorker(ctx context.Context) {
 	for {
 		select {
 		case <-ctx.Done():
-			log.Debugf("exiting")
 			return
 		case nextEnvelope := <-bs.engine.Outbox():
 			select {
@@ -275,8 +263,16 @@ func (bs *bitswap) clientWorker(parent context.Context) {
 
 	for {
 		select {
+		case <-time.Tick(10 * time.Second):
+			n := bs.wantlist.Len()
+			if n > 0 {
+				log.Debug(n, inflect.FromNumber("keys", n), "in bitswap wantlist")
+			}
 		case <-broadcastSignal: // resend unfulfilled wantlist keys
-			bs.sendWantlistToProviders(ctx)
+			entries := bs.wantlist.Entries()
+			if len(entries) > 0 {
+				bs.sendWantlistToProviders(ctx, entries)
+			}
 			broadcastSignal = time.After(rebroadcastDelay.Get())
 		case keys := <-bs.batchRequests:
 			if len(keys) == 0 {
@@ -304,7 +300,6 @@ func (bs *bitswap) clientWorker(parent context.Context) {
 // TODO(brian): handle errors
 func (bs *bitswap) ReceiveMessage(ctx context.Context, p peer.ID, incoming bsmsg.BitSwapMessage) (
 	peer.ID, bsmsg.BitSwapMessage) {
-	log.Debugf("ReceiveMessage from %s", p)
 
 	if p == "" {
 		log.Error("Received message from nil peer!")

exchange/bitswap/wantlist/wantlist.go

@@ -7,13 +7,14 @@ import (
 )
 
 type ThreadSafe struct {
-	lk sync.RWMutex
-	Wantlist
+	lk       sync.RWMutex
+	Wantlist Wantlist
 }
 
 // not threadsafe
 type Wantlist struct {
 	set map[u.Key]Entry
+	// TODO provide O(1) len accessor if cost becomes an issue
 }
 
 type Entry struct {
@@ -74,6 +75,16 @@ func (w *ThreadSafe) SortedEntries() []Entry {
 	return w.Wantlist.SortedEntries()
 }
 
+func (w *ThreadSafe) Len() int {
+	w.lk.RLock()
+	defer w.lk.RUnlock()
+	return w.Wantlist.Len()
+}
+
+func (w *Wantlist) Len() int {
+	return len(w.set)
+}
+
 func (w *Wantlist) Add(k u.Key, priority int) {
 	if _, ok := w.set[k]; ok {
 		return

p2p/crypto/secio/protocol.go

@@ -80,7 +80,6 @@ func (s *secureSession) handshake(ctx context.Context, insecure io.ReadWriter) e
 		return err
 	}
 
-	log.Debugf("handshake: %s <--start--> %s", s.localPeer, s.remotePeer)
 	defer log.EventBegin(ctx, "secureHandshake", s.localPeer).Done()
 
 	s.local.permanentPubKey = s.localKey.GetPublic()
@@ -293,7 +292,6 @@ func (s *secureSession) handshake(ctx context.Context, insecure io.ReadWriter) e
 	}
 
 	// Whew! ok, that's all folks.
-	log.Debugf("handshake: %s <--finish--> %s", s.localPeer, s.remotePeer)
 	log.Event(ctx, "secureHandshakeFinish", s.localPeer, s.remotePeer)
 	return nil
 }

routing/dht/query.go

@@ -85,10 +85,7 @@ func newQueryRunner(ctx context.Context, q *dhtQuery) *dhtQueryRunner {
 
 func (r *dhtQueryRunner) Run(peers []peer.ID) (*dhtQueryResult, error) {
 	r.log = log
-	log.Debug("enter")
-	defer log.Debug("end")
 
-	log.Debugf("Run query with %d peers.", len(peers))
 	if len(peers) == 0 {
 		log.Warning("Running query with no peers!")
 		return nil, nil
@@ -107,7 +104,6 @@ func (r *dhtQueryRunner) Run(peers []peer.ID) (*dhtQueryResult, error) {
 	// go do this thing.
 	// do it as a child func to make sure Run exits
 	// ONLY AFTER spawn workers has exited.
-	log.Debugf("go spawn workers")
 	r.cg.AddChildFunc(r.spawnWorkers)
 
 	// so workers are working.
@@ -117,7 +113,6 @@ func (r *dhtQueryRunner) Run(peers []peer.ID) (*dhtQueryResult, error) {
 
 	select {
 	case <-r.peersRemaining.Done():
-		log.Debug("all peers ended")
 		r.cg.Close()
 		r.RLock()
 		defer r.RUnlock()
@@ -139,11 +134,9 @@ func (r *dhtQueryRunner) Run(peers []peer.ID) (*dhtQueryResult, error) {
 	}
 
 	if r.result != nil && r.result.success {
-		log.Debug("success: %s", r.result)
 		return r.result, nil
 	}
 
-	log.Debug("failure: %s", err)
 	return nil, err
 }
 
@@ -155,11 +148,9 @@ func (r *dhtQueryRunner) addPeerToQuery(ctx context.Context, next peer.ID) {
 	}
 
 	if !r.peersSeen.TryAdd(next) {
-		r.log.Debugf("addPeerToQuery skip seen %s", next)
 		return
 	}
 
-	r.log.Debugf("addPeerToQuery adding %s", next)
 	r.peersRemaining.Increment(1)
 	select {
 	case r.peersToQuery.EnqChan <- next:
@@ -181,7 +172,6 @@ func (r *dhtQueryRunner) spawnWorkers(parent ctxgroup.ContextGroup) {
 			if !more {
 				return // channel closed.
 			}
-			log.Debugf("spawning worker for: %v", p)
 
 			// do it as a child func to make sure Run exits
 			// ONLY AFTER spawn workers has exited.
@@ -202,17 +192,16 @@ func (r *dhtQueryRunner) queryPeer(cg ctxgroup.ContextGroup, p peer.ID) {
 	}
 
 	// ok let's do this!
-	log.Debugf("running")
 
 	// make sure we do this when we exit
 	defer func() {
 		// signal we're done proccessing peer p
-		log.Debugf("completed")
 		r.peersRemaining.Decrement(1)
 		r.rateLimit <- struct{}{}
 	}()
 
 	// make sure we're connected to the peer.
+	// FIXME abstract away into the network layer
 	if conns := r.query.dht.host.Network().ConnsToPeer(p); len(conns) == 0 {
 		log.Infof("not connected. dialing.")
 		// while we dial, we do not take up a rate limit. this is to allow
@@ -239,9 +228,7 @@ func (r *dhtQueryRunner) queryPeer(cg ctxgroup.ContextGroup, p peer.ID) {
 	}
 
 	// finally, run the query against this peer
-	log.Debugf("query running")
 	res, err := r.query.qfunc(cg.Context(), p)
-	log.Debugf("query finished")
 
 	if err != nil {
 		log.Debugf("ERROR worker for: %v %v", p, err)

test/bench/offline_add/main.go

+package main
+
+import (
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/exec"
+	"path"
+	"testing"
+
+	"github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-random"
+	"github.com/jbenet/go-ipfs/repo/config"
+	"github.com/jbenet/go-ipfs/thirdparty/unit"
+)
+
+func main() {
+	if err := compareResults(); err != nil {
+		log.Fatal(err)
+	}
+}
+
+func compareResults() error {
+	var amount unit.Information
+	for amount = 10 * unit.MB; amount > 0; amount = amount * 2 {
+		if results, err := benchmarkAdd(int64(amount)); err != nil { // TODO compare
+			return err
+		} else {
+			log.Println(amount, "\t", results)
+		}
+	}
+	return nil
+}
+
+func benchmarkAdd(amount int64) (*testing.BenchmarkResult, error) {
+	results := testing.Benchmark(func(b *testing.B) {
+		b.SetBytes(amount)
+		for i := 0; i < b.N; i++ {
+			b.StopTimer()
+			tmpDir, err := ioutil.TempDir("", "")
+			if err != nil {
+				b.Fatal(err)
+			}
+			defer os.RemoveAll(tmpDir)
+
+			env := append(os.Environ(), fmt.Sprintf("%s=%s", config.EnvDir, path.Join(tmpDir, ".go-ipfs")))
+			setupCmd := func(cmd *exec.Cmd) {
+				cmd.Env = env
+			}
+
+			cmd := exec.Command("ipfs", "init", "-f", "-b=1024")
+			setupCmd(cmd)
+			if err := cmd.Run(); err != nil {
+				b.Fatal(err)
+			}
+
+			const seed = 1
+			f, err := ioutil.TempFile("", "")
+			if err != nil {
+				b.Fatal(err)
+			}
+			defer os.Remove(f.Name())
+
+			random.WritePseudoRandomBytes(amount, f, seed)
+			if err := f.Close(); err != nil {
+				b.Fatal(err)
+			}
+
+			b.StartTimer()
+			cmd = exec.Command("ipfs", "add", f.Name())
+			setupCmd(cmd)
+			if err := cmd.Run(); err != nil {
+				b.Fatal(err)
+			}
+			b.StopTimer()
+		}
+	})
+	return &results, nil
+}