Bump cAdvisor (and dependencies) godeps version

vendor/github.com/google/cadvisor/devicemapper/dmsetup_client.go

@@ -0,0 +1,56 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// 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 devicemapper
+
+import (
+	"os/exec"
+	"strconv"
+	"strings"
+
+	"github.com/golang/glog"
+)
+
+// DmsetupClient is a low-level client for interacting with devicemapper via
+// the dmsetup utility.
+type DmsetupClient interface {
+	Table(deviceName string) ([]byte, error)
+	Message(deviceName string, sector int, message string) ([]byte, error)
+	Status(deviceName string) ([]byte, error)
+}
+
+func NewDmsetupClient() DmsetupClient {
+	return &defaultDmsetupClient{}
+}
+
+// defaultDmsetupClient implements the standard behavior for interacting with dmsetup.
+type defaultDmsetupClient struct{}
+
+var _ DmsetupClient = &defaultDmsetupClient{}
+
+func (c *defaultDmsetupClient) Table(deviceName string) ([]byte, error) {
+	return c.dmsetup("table", deviceName)
+}
+
+func (c *defaultDmsetupClient) Message(deviceName string, sector int, message string) ([]byte, error) {
+	return c.dmsetup("message", deviceName, strconv.Itoa(sector), message)
+}
+
+func (c *defaultDmsetupClient) Status(deviceName string) ([]byte, error) {
+	return c.dmsetup("status", deviceName)
+}
+
+func (*defaultDmsetupClient) dmsetup(args ...string) ([]byte, error) {
+	glog.V(5).Infof("running dmsetup %v", strings.Join(args, " "))
+	return exec.Command("dmsetup", args...).Output()
+}

vendor/github.com/google/cadvisor/devicemapper/doc.go

@@ -0,0 +1,16 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// 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 devicemapper contains code for working with devicemapper
+package devicemapper

vendor/github.com/google/cadvisor/devicemapper/thin_ls_client.go

@@ -0,0 +1,77 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// 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 devicemapper
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+	"os/exec"
+	"strconv"
+	"strings"
+
+	"github.com/golang/glog"
+)
+
+// thinLsClient knows how to run a thin_ls very specific to CoW usage for containers.
+type thinLsClient interface {
+	ThinLs(deviceName string) (map[string]uint64, error)
+}
+
+func newThinLsClient() thinLsClient {
+	return &defaultThinLsClient{}
+}
+
+type defaultThinLsClient struct{}
+
+var _ thinLsClient = &defaultThinLsClient{}
+
+func (*defaultThinLsClient) ThinLs(deviceName string) (map[string]uint64, error) {
+	args := []string{"--no-headers", "-m", "-o", "DEV,EXCLUSIVE_BYTES", deviceName}
+	glog.V(4).Infof("running command: thin_ls %v", strings.Join(args, " "))
+
+	output, err := exec.Command("thin_ls", args...).Output()
+	if err != nil {
+		return nil, fmt.Errorf("Error running command `thin_ls %v`: %v\noutput:\n\n%v", strings.Join(args, " "), err, string(output))
+	}
+
+	return parseThinLsOutput(output), nil
+}
+
+// parseThinLsOutput parses the output returned by thin_ls to build a map of device id -> usage.
+func parseThinLsOutput(output []byte) map[string]uint64 {
+	cache := map[string]uint64{}
+
+	// parse output
+	scanner := bufio.NewScanner(bytes.NewReader(output))
+	for scanner.Scan() {
+		output := scanner.Text()
+		fields := strings.Fields(output)
+		if len(fields) != 2 {
+			continue
+		}
+
+		deviceID := fields[0]
+		usage, err := strconv.ParseUint(fields[1], 10, 64)
+		if err != nil {
+			glog.Warning("unexpected error parsing thin_ls output: %v", err)
+			continue
+		}
+
+		cache[deviceID] = usage
+	}
+
+	return cache
+
+}

vendor/github.com/google/cadvisor/devicemapper/thin_pool_watcher.go

@@ -0,0 +1,164 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// 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 devicemapper
+
+import (
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/golang/glog"
+)
+
+// ThinPoolWatcher maintains a cache of device name -> usage stats for a devicemapper thin-pool using thin_ls.
+type ThinPoolWatcher struct {
+	poolName       string
+	metadataDevice string
+	lock           *sync.RWMutex
+	cache          map[string]uint64
+	period         time.Duration
+	stopChan       chan struct{}
+	dmsetup        DmsetupClient
+	thinLsClient   thinLsClient
+}
+
+// NewThinPoolWatcher returns a new ThinPoolWatcher for the given devicemapper thin pool name and metadata device.
+func NewThinPoolWatcher(poolName, metadataDevice string) *ThinPoolWatcher {
+	return &ThinPoolWatcher{poolName: poolName,
+		metadataDevice: metadataDevice,
+		lock:           &sync.RWMutex{},
+		cache:          make(map[string]uint64),
+		period:         15 * time.Second,
+		stopChan:       make(chan struct{}),
+		dmsetup:        NewDmsetupClient(),
+		thinLsClient:   newThinLsClient(),
+	}
+}
+
+// Start starts the thin pool watcher.
+func (w *ThinPoolWatcher) Start() {
+	err := w.Refresh()
+	if err != nil {
+		glog.Errorf("encountered error refreshing thin pool watcher: %v", err)
+	}
+
+	for {
+		select {
+		case <-w.stopChan:
+			return
+		case <-time.After(w.period):
+			start := time.Now()
+			err = w.Refresh()
+			if err != nil {
+				glog.Errorf("encountered error refreshing thin pool watcher: %v", err)
+			}
+
+			// print latency for refresh
+			duration := time.Since(start)
+			glog.V(3).Infof("thin_ls(%d) took %s", start.Unix(), duration)
+		}
+	}
+}
+
+func (w *ThinPoolWatcher) Stop() {
+	close(w.stopChan)
+}
+
+// GetUsage gets the cached usage value of the given device.
+func (w *ThinPoolWatcher) GetUsage(deviceId string) (uint64, error) {
+	w.lock.RLock()
+	defer w.lock.RUnlock()
+	v, ok := w.cache[deviceId]
+	if !ok {
+		return 0, fmt.Errorf("no cached value for usage of device %v", deviceId)
+	}
+
+	return v, nil
+}
+
+const (
+	reserveMetadataMessage = "reserve_metadata_snap"
+	releaseMetadataMessage = "release_metadata_snap"
+)
+
+// Refresh performs a `thin_ls` of the pool being watched and refreshes the
+// cached data with the result.
+func (w *ThinPoolWatcher) Refresh() error {
+	w.lock.Lock()
+	defer w.lock.Unlock()
+
+	currentlyReserved, err := w.checkReservation(w.poolName)
+	if err != nil {
+		err = fmt.Errorf("error determining whether snapshot is reserved: %v", err)
+		return err
+	}
+
+	if currentlyReserved {
+		glog.V(4).Infof("metadata for %v is currently reserved; releasing", w.poolName)
+		_, err = w.dmsetup.Message(w.poolName, 0, releaseMetadataMessage)
+		if err != nil {
+			err = fmt.Errorf("error releasing metadata snapshot for %v: %v", w.poolName, err)
+			return err
+		}
+	}
+
+	glog.Infof("reserving metadata snapshot for thin-pool %v", w.poolName)
+	// NOTE: "0" in the call below is for the 'sector' argument to 'dmsetup message'.  It's not needed for thin pools.
+	if output, err := w.dmsetup.Message(w.poolName, 0, reserveMetadataMessage); err != nil {
+		err = fmt.Errorf("error reserving metadata for thin-pool %v: %v output: %v", w.poolName, err, string(output))
+		return err
+	} else {
+		glog.V(5).Infof("reserved metadata snapshot for thin-pool %v", w.poolName)
+	}
+
+	defer func() {
+		glog.V(5).Infof("releasing metadata snapshot for thin-pool %v", w.poolName)
+		w.dmsetup.Message(w.poolName, 0, releaseMetadataMessage)
+	}()
+
+	glog.V(5).Infof("running thin_ls on metadata device %v", w.metadataDevice)
+	newCache, err := w.thinLsClient.ThinLs(w.metadataDevice)
+	if err != nil {
+		err = fmt.Errorf("error performing thin_ls on metadata device %v: %v", w.metadataDevice, err)
+		return err
+	}
+
+	w.cache = newCache
+	return nil
+}
+
+const (
+	thinPoolDmsetupStatusTokens           = 11
+	thinPoolDmsetupStatusHeldMetadataRoot = 6
+)
+
+// checkReservation checks to see whether the thin device is currently holding userspace metadata.
+func (w *ThinPoolWatcher) checkReservation(poolName string) (bool, error) {
+	glog.V(5).Infof("checking whether the thin-pool is holding a metadata snapshot")
+	output, err := w.dmsetup.Status(poolName)
+	if err != nil {
+		return false, err
+	}
+
+	tokens := strings.Split(string(output), " ")
+	// Split returns the input as the last item in the result, adjust the number of tokens by one
+	if len(tokens) != thinPoolDmsetupStatusTokens+1 {
+		return false, fmt.Errorf("unexpected output of dmsetup status command; expected 11 fields, got %v; output: %v", len(tokens), string(output))
+	}
+
+	heldMetadataRoot := tokens[thinPoolDmsetupStatusHeldMetadataRoot]
+	currentlyReserved := heldMetadataRoot != "-"
+	return currentlyReserved, nil
+}