Upgrading server dependancies (#6215)

vendor/github.com/prometheus/common/.travis.yml

@@ -2,6 +2,5 @@ sudo: false
 
 language: go
 go:
-  - 1.5.4
-  - 1.6.2
+  - 1.7.5
   - tip

vendor/github.com/prometheus/common/route/route.go

@@ -1,26 +1,12 @@
 package route
 
 import (
-	"fmt"
 	"net/http"
-	"sync"
 
 	"github.com/julienschmidt/httprouter"
 	"golang.org/x/net/context"
 )
 
-var (
-	mtx   = sync.RWMutex{}
-	ctxts = map[*http.Request]context.Context{}
-)
-
-// Context returns the context for the request.
-func Context(r *http.Request) context.Context {
-	mtx.RLock()
-	defer mtx.RUnlock()
-	return ctxts[r]
-}
-
 type param string
 
 // Param returns param p for the context.
@@ -33,59 +19,35 @@ func WithParam(ctx context.Context, p, v string) context.Context {
 	return context.WithValue(ctx, param(p), v)
 }
 
-// ContextFunc returns a new context for a request.
-type ContextFunc func(r *http.Request) (context.Context, error)
-
 // Router wraps httprouter.Router and adds support for prefixed sub-routers
 // and per-request context injections.
 type Router struct {
 	rtr    *httprouter.Router
 	prefix string
-	ctxFn  ContextFunc
 }
 
 // New returns a new Router.
-func New(ctxFn ContextFunc) *Router {
-	if ctxFn == nil {
-		ctxFn = func(r *http.Request) (context.Context, error) {
-			return context.Background(), nil
-		}
-	}
+func New() *Router {
 	return &Router{
-		rtr:   httprouter.New(),
-		ctxFn: ctxFn,
+		rtr: httprouter.New(),
 	}
 }
 
 // WithPrefix returns a router that prefixes all registered routes with prefix.
 func (r *Router) WithPrefix(prefix string) *Router {
-	return &Router{rtr: r.rtr, prefix: r.prefix + prefix, ctxFn: r.ctxFn}
+	return &Router{rtr: r.rtr, prefix: r.prefix + prefix}
 }
 
 // handle turns a HandlerFunc into an httprouter.Handle.
 func (r *Router) handle(h http.HandlerFunc) httprouter.Handle {
 	return func(w http.ResponseWriter, req *http.Request, params httprouter.Params) {
-		reqCtx, err := r.ctxFn(req)
-		if err != nil {
-			http.Error(w, fmt.Sprintf("Error creating request context: %v", err), http.StatusBadRequest)
-			return
-		}
-		ctx, cancel := context.WithCancel(reqCtx)
+		ctx, cancel := context.WithCancel(req.Context())
 		defer cancel()
 
 		for _, p := range params {
 			ctx = context.WithValue(ctx, param(p.Key), p.Value)
 		}
-
-		mtx.Lock()
-		ctxts[req] = ctx
-		mtx.Unlock()
-
-		h(w, req)
-
-		mtx.Lock()
-		delete(ctxts, req)
-		mtx.Unlock()
+		h(w, req.WithContext(ctx))
 	}
 }
 
@@ -132,7 +94,7 @@ func FileServe(dir string) http.HandlerFunc {
 	fs := http.FileServer(http.Dir(dir))
 
 	return func(w http.ResponseWriter, r *http.Request) {
-		r.URL.Path = Param(Context(r), "filepath")
+		r.URL.Path = Param(r.Context(), "filepath")
 		fs.ServeHTTP(w, r)
 	}
 }

vendor/github.com/prometheus/common/route/route_test.go

@@ -1,16 +1,13 @@
 package route
 
 import (
-	"fmt"
 	"net/http"
 	"net/http/httptest"
 	"testing"
-
-	"golang.org/x/net/context"
 )
 
 func TestRedirect(t *testing.T) {
-	router := New(nil).WithPrefix("/test/prefix")
+	router := New().WithPrefix("/test/prefix")
 	w := httptest.NewRecorder()
 	r, err := http.NewRequest("GET", "http://localhost:9090/foo", nil)
 	if err != nil {
@@ -29,47 +26,19 @@ func TestRedirect(t *testing.T) {
 	}
 }
 
-func TestContextFunc(t *testing.T) {
-	router := New(func(r *http.Request) (context.Context, error) {
-		return context.WithValue(context.Background(), "testkey", "testvalue"), nil
-	})
-
-	router.Get("/test", func(w http.ResponseWriter, r *http.Request) {
-		want := "testvalue"
-		got := Context(r).Value("testkey")
+func TestContext(t *testing.T) {
+	router := New()
+	router.Get("/test/:foo/", func(w http.ResponseWriter, r *http.Request) {
+		want := "bar"
+		got := Param(r.Context(), "foo")
 		if want != got {
 			t.Fatalf("Unexpected context value: want %q, got %q", want, got)
 		}
 	})
 
-	r, err := http.NewRequest("GET", "http://localhost:9090/test", nil)
+	r, err := http.NewRequest("GET", "http://localhost:9090/test/bar/", nil)
 	if err != nil {
 		t.Fatalf("Error building test request: %s", err)
 	}
 	router.ServeHTTP(nil, r)
 }
-
-func TestContextFnError(t *testing.T) {
-	router := New(func(r *http.Request) (context.Context, error) {
-		return context.Background(), fmt.Errorf("test error")
-	})
-
-	router.Get("/test", func(w http.ResponseWriter, r *http.Request) {})
-
-	r, err := http.NewRequest("GET", "http://localhost:9090/test", nil)
-	if err != nil {
-		t.Fatalf("Error building test request: %s", err)
-	}
-	w := httptest.NewRecorder()
-	router.ServeHTTP(w, r)
-
-	if w.Code != http.StatusBadRequest {
-		t.Fatalf("Unexpected response status: got %q, want %q", w.Code, http.StatusBadRequest)
-	}
-
-	want := "Error creating request context: test error\n"
-	got := w.Body.String()
-	if want != got {
-		t.Fatalf("Unexpected response body: got %q, want %q", got, want)
-	}
-}

vendor/github.com/prometheus/procfs/sysfs/doc.go

@@ -0,0 +1,16 @@
+// Copyright 2017 The Prometheus Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package sysfs provides functions to retrieve system and kernel metrics
+// from the pseudo-filesystem sys.
+package sysfs

vendor/github.com/prometheus/procfs/sysfs/fixtures/fs/xfs/sda1/stats/stats

@@ -0,0 +1 @@
+extent_alloc 1 0 0 0

vendor/github.com/prometheus/procfs/sysfs/fixtures/fs/xfs/sdb1/stats/stats

@@ -0,0 +1 @@
+extent_alloc 2 0 0 0

vendor/github.com/prometheus/procfs/sysfs/fs.go

@@ -0,0 +1,82 @@
+// Copyright 2017 The Prometheus Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package sysfs
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/prometheus/procfs/xfs"
+)
+
+// FS represents the pseudo-filesystem sys, which provides an interface to
+// kernel data structures.
+type FS string
+
+// DefaultMountPoint is the common mount point of the sys filesystem.
+const DefaultMountPoint = "/sys"
+
+// NewFS returns a new FS mounted under the given mountPoint. It will error
+// if the mount point can't be read.
+func NewFS(mountPoint string) (FS, error) {
+	info, err := os.Stat(mountPoint)
+	if err != nil {
+		return "", fmt.Errorf("could not read %s: %s", mountPoint, err)
+	}
+	if !info.IsDir() {
+		return "", fmt.Errorf("mount point %s is not a directory", mountPoint)
+	}
+
+	return FS(mountPoint), nil
+}
+
+// Path returns the path of the given subsystem relative to the sys root.
+func (fs FS) Path(p ...string) string {
+	return filepath.Join(append([]string{string(fs)}, p...)...)
+}
+
+// XFSStats retrieves XFS filesystem runtime statistics for each mounted XFS
+// filesystem.  Only available on kernel 4.4+.  On older kernels, an empty
+// slice of *xfs.Stats will be returned.
+func (fs FS) XFSStats() ([]*xfs.Stats, error) {
+	matches, err := filepath.Glob(fs.Path("fs/xfs/*/stats/stats"))
+	if err != nil {
+		return nil, err
+	}
+
+	stats := make([]*xfs.Stats, 0, len(matches))
+	for _, m := range matches {
+		f, err := os.Open(m)
+		if err != nil {
+			return nil, err
+		}
+
+		// "*" used in glob above indicates the name of the filesystem.
+		name := filepath.Base(filepath.Dir(filepath.Dir(m)))
+
+		// File must be closed after parsing, regardless of success or
+		// failure.  Defer is not used because of the loop.
+		s, err := xfs.ParseStats(f)
+		_ = f.Close()
+		if err != nil {
+			return nil, err
+		}
+
+		s.Name = name
+		stats = append(stats, s)
+	}
+
+	return stats, nil
+}

vendor/github.com/prometheus/procfs/sysfs/fs_test.go

@@ -0,0 +1,66 @@
+// Copyright 2017 The Prometheus Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package sysfs
+
+import "testing"
+
+func TestNewFS(t *testing.T) {
+	if _, err := NewFS("foobar"); err == nil {
+		t.Error("want NewFS to fail for non-existing mount point")
+	}
+
+	if _, err := NewFS("doc.go"); err == nil {
+		t.Error("want NewFS to fail if mount point is not a directory")
+	}
+}
+
+func TestFSXFSStats(t *testing.T) {
+	stats, err := FS("fixtures").XFSStats()
+	if err != nil {
+		t.Fatalf("failed to parse XFS stats: %v", err)
+	}
+
+	tests := []struct {
+		name      string
+		allocated uint32
+	}{
+		{
+			name:      "sda1",
+			allocated: 1,
+		},
+		{
+			name:      "sdb1",
+			allocated: 2,
+		},
+	}
+
+	const expect = 2
+
+	if l := len(stats); l != expect {
+		t.Fatalf("unexpected number of XFS stats: %d", l)
+	}
+	if l := len(tests); l != expect {
+		t.Fatalf("unexpected number of tests: %d", l)
+	}
+
+	for i, tt := range tests {
+		if want, got := tt.name, stats[i].Name; want != got {
+			t.Errorf("unexpected stats name:\nwant: %q\nhave: %q", want, got)
+		}
+
+		if want, got := tt.allocated, stats[i].ExtentAllocation.ExtentsAllocated; want != got {
+			t.Errorf("unexpected extents allocated:\nwant: %d\nhave: %d", want, got)
+		}
+	}
+}

vendor/github.com/prometheus/procfs/xfs/parse.go

@@ -17,7 +17,6 @@ import (
 	"bufio"
 	"fmt"
 	"io"
-	"log"
 	"strconv"
 	"strings"
 )
@@ -273,7 +272,6 @@ func vnodeStats(us []uint32) (VnodeStats, error) {
 	// stats versions.  Therefore, 7 or 8 elements may appear in
 	// this slice.
 	l := len(us)
-	log.Println(l)
 	if l != 7 && l != 8 {
 		return VnodeStats{}, fmt.Errorf("incorrect number of values for XFS vnode stats: %d", l)
 	}

vendor/github.com/prometheus/procfs/xfs/parse_test.go

@@ -14,7 +14,6 @@
 package xfs_test
 
 import (
-	"log"
 	"reflect"
 	"strings"
 	"testing"
@@ -416,9 +415,7 @@ func TestParseStats(t *testing.T) {
 		},
 	}
 
-	for i, tt := range tests {
-		t.Logf("[%02d] test %q", i, tt.name)
-
+	for _, tt := range tests {
 		var (
 			stats *xfs.Stats
 			err   error
@@ -439,7 +436,6 @@ func TestParseStats(t *testing.T) {
 		}
 
 		if want, have := tt.stats, stats; !reflect.DeepEqual(want, have) {
-			log.Printf("stats: %#v", have)
 			t.Errorf("unexpected XFS stats:\nwant:\n%v\nhave:\n%v", want, have)
 		}
 	}

vendor/github.com/prometheus/procfs/xfs/xfs.go

@@ -22,6 +22,11 @@ package xfs
 // kernel source. Most counters are uint32s (same data types used in
 // xfs_stats.h), but some of the "extended precision stats" are uint64s.
 type Stats struct {
+	// The name of the filesystem used to source these statistics.
+	// If empty, this indicates aggregated statistics for all XFS
+	// filesystems on the host.
+	Name string
+
 	ExtentAllocation   ExtentAllocationStats
 	AllocationBTree    BTreeStats
 	BlockMapping       BlockMappingStats