Move deps from _workspace/ to vendor/

godep restore pushd $GOPATH/src/github.com/appc/spec git co master popd go get go4.org/errorutil rm -rf Godeps godep save ./... git add vendor git add -f $(git ls-files --other vendor/) git co -- Godeps/LICENSES Godeps/.license_file_state Godeps/OWNERS
2025-10-12 10:09:04 +00:00 · 2016-05-08 20:30:21 -07:00
parent 899f9b4e31
commit 3c0c5ed4e0
4400 changed files with 16739 additions and 376 deletions
--- a/vendor/github.com/google/cadvisor/fs/fs.go
+++ b/vendor/github.com/google/cadvisor/fs/fs.go
@@ -0,0 +1,545 @@
+// Copyright 2014 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.
+
+// +build linux
+
+// Provides Filesystem Stats
+package fs
+
+import (
+	"bufio"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/docker/docker/pkg/mount"
+	"github.com/golang/glog"
+	zfs "github.com/mistifyio/go-zfs"
+)
+
+const (
+	LabelSystemRoot   = "root"
+	LabelDockerImages = "docker-images"
+	LabelRktImages    = "rkt-images"
+)
+
+type partition struct {
+	mountpoint string
+	major      uint
+	minor      uint
+	fsType     string
+	blockSize  uint
+}
+
+type RealFsInfo struct {
+	// Map from block device path to partition information.
+	partitions map[string]partition
+	// Map from label to block device path.
+	// Labels are intent-specific tags that are auto-detected.
+	labels map[string]string
+
+	dmsetup dmsetupClient
+}
+
+type Context struct {
+	// docker root directory.
+	Docker  DockerContext
+	RktPath string
+}
+
+type DockerContext struct {
+	Root         string
+	Driver       string
+	DriverStatus map[string]string
+}
+
+func NewFsInfo(context Context) (FsInfo, error) {
+	mounts, err := mount.GetMounts()
+	if err != nil {
+		return nil, err
+	}
+	fsInfo := &RealFsInfo{
+		partitions: make(map[string]partition, 0),
+		labels:     make(map[string]string, 0),
+		dmsetup:    &defaultDmsetupClient{},
+	}
+
+	fsInfo.addSystemRootLabel(mounts)
+	fsInfo.addDockerImagesLabel(context, mounts)
+	fsInfo.addRktImagesLabel(context, mounts)
+
+	supportedFsType := map[string]bool{
+		// all ext systems are checked through prefix.
+		"btrfs": true,
+		"xfs":   true,
+		"zfs":   true,
+	}
+	for _, mount := range mounts {
+		var Fstype string
+		if !strings.HasPrefix(mount.Fstype, "ext") && !supportedFsType[mount.Fstype] {
+			continue
+		}
+		// Avoid bind mounts.
+		if _, ok := fsInfo.partitions[mount.Source]; ok {
+			continue
+		}
+		if mount.Fstype == "zfs" {
+			Fstype = mount.Fstype
+		}
+		fsInfo.partitions[mount.Source] = partition{
+			fsType:     Fstype,
+			mountpoint: mount.Mountpoint,
+			major:      uint(mount.Major),
+			minor:      uint(mount.Minor),
+		}
+	}
+
+	glog.Infof("Filesystem partitions: %+v", fsInfo.partitions)
+	return fsInfo, nil
+}
+
+// getDockerDeviceMapperInfo returns information about the devicemapper device and "partition" if
+// docker is using devicemapper for its storage driver. If a loopback device is being used, don't
+// return any information or error, as we want to report based on the actual partition where the
+// loopback file resides, inside of the loopback file itself.
+func (self *RealFsInfo) getDockerDeviceMapperInfo(context DockerContext) (string, *partition, error) {
+	if context.Driver != DeviceMapper.String() {
+		return "", nil, nil
+	}
+
+	dataLoopFile := context.DriverStatus["Data loop file"]
+	if len(dataLoopFile) > 0 {
+		return "", nil, nil
+	}
+
+	dev, major, minor, blockSize, err := dockerDMDevice(context.DriverStatus, self.dmsetup)
+	if err != nil {
+		return "", nil, err
+	}
+
+	return dev, &partition{
+		fsType:    DeviceMapper.String(),
+		major:     major,
+		minor:     minor,
+		blockSize: blockSize,
+	}, nil
+}
+
+// addSystemRootLabel attempts to determine which device contains the mount for /.
+func (self *RealFsInfo) addSystemRootLabel(mounts []*mount.Info) {
+	for _, m := range mounts {
+		if m.Mountpoint == "/" {
+			self.partitions[m.Source] = partition{
+				fsType:     m.Fstype,
+				mountpoint: m.Mountpoint,
+				major:      uint(m.Major),
+				minor:      uint(m.Minor),
+			}
+			self.labels[LabelSystemRoot] = m.Source
+			return
+		}
+	}
+}
+
+// addDockerImagesLabel attempts to determine which device contains the mount for docker images.
+func (self *RealFsInfo) addDockerImagesLabel(context Context, mounts []*mount.Info) {
+	dockerDev, dockerPartition, err := self.getDockerDeviceMapperInfo(context.Docker)
+	if err != nil {
+		glog.Warningf("Could not get Docker devicemapper device: %v", err)
+	}
+	if len(dockerDev) > 0 && dockerPartition != nil {
+		self.partitions[dockerDev] = *dockerPartition
+		self.labels[LabelDockerImages] = dockerDev
+	} else {
+		self.updateContainerImagesPath(LabelDockerImages, mounts, getDockerImagePaths(context))
+	}
+}
+
+func (self *RealFsInfo) addRktImagesLabel(context Context, mounts []*mount.Info) {
+	if context.RktPath != "" {
+		rktPath := context.RktPath
+		rktImagesPaths := map[string]struct{}{
+			"/": {},
+		}
+		for rktPath != "/" && rktPath != "." {
+			rktImagesPaths[rktPath] = struct{}{}
+			rktPath = filepath.Dir(rktPath)
+		}
+		self.updateContainerImagesPath(LabelRktImages, mounts, rktImagesPaths)
+	}
+}
+
+// Generate a list of possible mount points for docker image management from the docker root directory.
+// Right now, we look for each type of supported graph driver directories, but we can do better by parsing
+// some of the context from `docker info`.
+func getDockerImagePaths(context Context) map[string]struct{} {
+	dockerImagePaths := map[string]struct{}{
+		"/": {},
+	}
+
+	// TODO(rjnagal): Detect docker root and graphdriver directories from docker info.
+	dockerRoot := context.Docker.Root
+	for _, dir := range []string{"devicemapper", "btrfs", "aufs", "overlay", "zfs"} {
+		dockerImagePaths[path.Join(dockerRoot, dir)] = struct{}{}
+	}
+	for dockerRoot != "/" && dockerRoot != "." {
+		dockerImagePaths[dockerRoot] = struct{}{}
+		dockerRoot = filepath.Dir(dockerRoot)
+	}
+	return dockerImagePaths
+}
+
+// This method compares the mountpoints with possible container image mount points. If a match is found,
+// the label is added to the partition.
+func (self *RealFsInfo) updateContainerImagesPath(label string, mounts []*mount.Info, containerImagePaths map[string]struct{}) {
+	var useMount *mount.Info
+	for _, m := range mounts {
+		if _, ok := containerImagePaths[m.Mountpoint]; ok {
+			if useMount == nil || (len(useMount.Mountpoint) < len(m.Mountpoint)) {
+				useMount = m
+			}
+		}
+	}
+	if useMount != nil {
+		self.partitions[useMount.Source] = partition{
+			fsType:     useMount.Fstype,
+			mountpoint: useMount.Mountpoint,
+			major:      uint(useMount.Major),
+			minor:      uint(useMount.Minor),
+		}
+		self.labels[label] = useMount.Source
+	}
+}
+
+func (self *RealFsInfo) GetDeviceForLabel(label string) (string, error) {
+	dev, ok := self.labels[label]
+	if !ok {
+		return "", fmt.Errorf("non-existent label %q", label)
+	}
+	return dev, nil
+}
+
+func (self *RealFsInfo) GetLabelsForDevice(device string) ([]string, error) {
+	labels := []string{}
+	for label, dev := range self.labels {
+		if dev == device {
+			labels = append(labels, label)
+		}
+	}
+	return labels, nil
+}
+
+func (self *RealFsInfo) GetMountpointForDevice(dev string) (string, error) {
+	p, ok := self.partitions[dev]
+	if !ok {
+		return "", fmt.Errorf("no partition info for device %q", dev)
+	}
+	return p.mountpoint, nil
+}
+
+func (self *RealFsInfo) GetFsInfoForPath(mountSet map[string]struct{}) ([]Fs, error) {
+	filesystems := make([]Fs, 0)
+	deviceSet := make(map[string]struct{})
+	diskStatsMap, err := getDiskStatsMap("/proc/diskstats")
+	if err != nil {
+		return nil, err
+	}
+	for device, partition := range self.partitions {
+		_, hasMount := mountSet[partition.mountpoint]
+		_, hasDevice := deviceSet[device]
+		if mountSet == nil || (hasMount && !hasDevice) {
+			var (
+				err error
+				fs  Fs
+			)
+			switch partition.fsType {
+			case DeviceMapper.String():
+				fs.Capacity, fs.Free, fs.Available, err = getDMStats(device, partition.blockSize)
+				fs.Type = DeviceMapper
+			case ZFS.String():
+				fs.Capacity, fs.Free, fs.Available, err = getZfstats(device)
+				fs.Type = ZFS
+			default:
+				fs.Capacity, fs.Free, fs.Available, fs.Inodes, fs.InodesFree, err = getVfsStats(partition.mountpoint)
+				fs.Type = VFS
+			}
+			if err != nil {
+				glog.Errorf("Stat fs failed. Error: %v", err)
+			} else {
+				deviceSet[device] = struct{}{}
+				fs.DeviceInfo = DeviceInfo{
+					Device: device,
+					Major:  uint(partition.major),
+					Minor:  uint(partition.minor),
+				}
+				fs.DiskStats = diskStatsMap[device]
+				filesystems = append(filesystems, fs)
+			}
+		}
+	}
+	return filesystems, nil
+}
+
+var partitionRegex = regexp.MustCompile(`^(?:(?:s|xv)d[a-z]+\d*|dm-\d+)$`)
+
+func getDiskStatsMap(diskStatsFile string) (map[string]DiskStats, error) {
+	diskStatsMap := make(map[string]DiskStats)
+	file, err := os.Open(diskStatsFile)
+	if err != nil {
+		if os.IsNotExist(err) {
+			glog.Infof("not collecting filesystem statistics because file %q was not available", diskStatsFile)
+			return diskStatsMap, nil
+		}
+		return nil, err
+	}
+
+	defer file.Close()
+	scanner := bufio.NewScanner(file)
+
+	for scanner.Scan() {
+		line := scanner.Text()
+		words := strings.Fields(line)
+		if !partitionRegex.MatchString(words[2]) {
+			continue
+		}
+		// 8      50 sdd2 40 0 280 223 7 0 22 108 0 330 330
+		deviceName := path.Join("/dev", words[2])
+		wordLength := len(words)
+		offset := 3
+		var stats = make([]uint64, wordLength-offset)
+		if len(stats) < 11 {
+			return nil, fmt.Errorf("could not parse all 11 columns of /proc/diskstats")
+		}
+		var error error
+		for i := offset; i < wordLength; i++ {
+			stats[i-offset], error = strconv.ParseUint(words[i], 10, 64)
+			if error != nil {
+				return nil, error
+			}
+		}
+		diskStats := DiskStats{
+			ReadsCompleted:  stats[0],
+			ReadsMerged:     stats[1],
+			SectorsRead:     stats[2],
+			ReadTime:        stats[3],
+			WritesCompleted: stats[4],
+			WritesMerged:    stats[5],
+			SectorsWritten:  stats[6],
+			WriteTime:       stats[7],
+			IoInProgress:    stats[8],
+			IoTime:          stats[9],
+			WeightedIoTime:  stats[10],
+		}
+		diskStatsMap[deviceName] = diskStats
+	}
+	return diskStatsMap, nil
+}
+
+func (self *RealFsInfo) GetGlobalFsInfo() ([]Fs, error) {
+	return self.GetFsInfoForPath(nil)
+}
+
+func major(devNumber uint64) uint {
+	return uint((devNumber >> 8) & 0xfff)
+}
+
+func minor(devNumber uint64) uint {
+	return uint((devNumber & 0xff) | ((devNumber >> 12) & 0xfff00))
+}
+
+func (self *RealFsInfo) GetDirFsDevice(dir string) (*DeviceInfo, error) {
+	buf := new(syscall.Stat_t)
+	err := syscall.Stat(dir, buf)
+	if err != nil {
+		return nil, fmt.Errorf("stat failed on %s with error: %s", dir, err)
+	}
+	major := major(buf.Dev)
+	minor := minor(buf.Dev)
+	for device, partition := range self.partitions {
+		if partition.major == major && partition.minor == minor {
+			return &DeviceInfo{device, major, minor}, nil
+		}
+	}
+	return nil, fmt.Errorf("could not find device with major: %d, minor: %d in cached partitions map", major, minor)
+}
+
+func (self *RealFsInfo) GetDirUsage(dir string, timeout time.Duration) (uint64, error) {
+	if dir == "" {
+		return 0, fmt.Errorf("invalid directory")
+	}
+	cmd := exec.Command("nice", "-n", "19", "du", "-s", dir)
+	stdoutp, err := cmd.StdoutPipe()
+	if err != nil {
+		return 0, fmt.Errorf("failed to setup stdout for cmd %v - %v", cmd.Args, err)
+	}
+	stderrp, err := cmd.StderrPipe()
+	if err != nil {
+		return 0, fmt.Errorf("failed to setup stderr for cmd %v - %v", cmd.Args, err)
+	}
+
+	if err := cmd.Start(); err != nil {
+		return 0, fmt.Errorf("failed to exec du - %v", err)
+	}
+	stdoutb, souterr := ioutil.ReadAll(stdoutp)
+	stderrb, _ := ioutil.ReadAll(stderrp)
+	timer := time.AfterFunc(timeout, func() {
+		glog.Infof("killing cmd %v due to timeout(%s)", cmd.Args, timeout.String())
+		cmd.Process.Kill()
+	})
+	err = cmd.Wait()
+	timer.Stop()
+	if err != nil {
+		return 0, fmt.Errorf("du command failed on %s with output stdout: %s, stderr: %s - %v", dir, string(stdoutb), string(stderrb), err)
+	}
+	stdout := string(stdoutb)
+	if souterr != nil {
+		glog.Errorf("failed to read from stdout for cmd %v - %v", cmd.Args, souterr)
+	}
+	usageInKb, err := strconv.ParseUint(strings.Fields(stdout)[0], 10, 64)
+	if err != nil {
+		return 0, fmt.Errorf("cannot parse 'du' output %s - %s", stdout, err)
+	}
+	return usageInKb * 1024, nil
+}
+
+func getVfsStats(path string) (total uint64, free uint64, avail uint64, inodes uint64, inodesFree uint64, err error) {
+	var s syscall.Statfs_t
+	if err = syscall.Statfs(path, &s); err != nil {
+		return 0, 0, 0, 0, 0, err
+	}
+	total = uint64(s.Frsize) * s.Blocks
+	free = uint64(s.Frsize) * s.Bfree
+	avail = uint64(s.Frsize) * s.Bavail
+	inodes = uint64(s.Files)
+	inodesFree = uint64(s.Ffree)
+	return total, free, avail, inodes, inodesFree, nil
+}
+
+// dmsetupClient knows to to interact with dmsetup to retrieve information about devicemapper.
+type dmsetupClient interface {
+	table(poolName string) ([]byte, error)
+	//TODO add status(poolName string) ([]byte, error) and use it in getDMStats so we can unit test
+}
+
+// defaultDmsetupClient implements the standard behavior for interacting with dmsetup.
+type defaultDmsetupClient struct{}
+
+var _ dmsetupClient = &defaultDmsetupClient{}
+
+func (*defaultDmsetupClient) table(poolName string) ([]byte, error) {
+	return exec.Command("dmsetup", "table", poolName).Output()
+}
+
+// Devicemapper thin provisioning is detailed at
+// https://www.kernel.org/doc/Documentation/device-mapper/thin-provisioning.txt
+func dockerDMDevice(driverStatus map[string]string, dmsetup dmsetupClient) (string, uint, uint, uint, error) {
+	poolName, ok := driverStatus["Pool Name"]
+	if !ok || len(poolName) == 0 {
+		return "", 0, 0, 0, fmt.Errorf("Could not get dm pool name")
+	}
+
+	out, err := dmsetup.table(poolName)
+	if err != nil {
+		return "", 0, 0, 0, err
+	}
+
+	major, minor, dataBlkSize, err := parseDMTable(string(out))
+	if err != nil {
+		return "", 0, 0, 0, err
+	}
+
+	return poolName, major, minor, dataBlkSize, nil
+}
+
+func parseDMTable(dmTable string) (uint, uint, uint, error) {
+	dmTable = strings.Replace(dmTable, ":", " ", -1)
+	dmFields := strings.Fields(dmTable)
+
+	if len(dmFields) < 8 {
+		return 0, 0, 0, fmt.Errorf("Invalid dmsetup status output: %s", dmTable)
+	}
+
+	major, err := strconv.ParseUint(dmFields[5], 10, 32)
+	if err != nil {
+		return 0, 0, 0, err
+	}
+	minor, err := strconv.ParseUint(dmFields[6], 10, 32)
+	if err != nil {
+		return 0, 0, 0, err
+	}
+	dataBlkSize, err := strconv.ParseUint(dmFields[7], 10, 32)
+	if err != nil {
+		return 0, 0, 0, err
+	}
+
+	return uint(major), uint(minor), uint(dataBlkSize), nil
+}
+
+func getDMStats(poolName string, dataBlkSize uint) (uint64, uint64, uint64, error) {
+	out, err := exec.Command("dmsetup", "status", poolName).Output()
+	if err != nil {
+		return 0, 0, 0, err
+	}
+
+	used, total, err := parseDMStatus(string(out))
+	if err != nil {
+		return 0, 0, 0, err
+	}
+
+	used *= 512 * uint64(dataBlkSize)
+	total *= 512 * uint64(dataBlkSize)
+	free := total - used
+
+	return total, free, free, nil
+}
+
+func parseDMStatus(dmStatus string) (uint64, uint64, error) {
+	dmStatus = strings.Replace(dmStatus, "/", " ", -1)
+	dmFields := strings.Fields(dmStatus)
+
+	if len(dmFields) < 8 {
+		return 0, 0, fmt.Errorf("Invalid dmsetup status output: %s", dmStatus)
+	}
+
+	used, err := strconv.ParseUint(dmFields[6], 10, 64)
+	if err != nil {
+		return 0, 0, err
+	}
+	total, err := strconv.ParseUint(dmFields[7], 10, 64)
+	if err != nil {
+		return 0, 0, err
+	}
+
+	return used, total, nil
+}
+
+// getZfstats returns ZFS mount stats using zfsutils
+func getZfstats(poolName string) (uint64, uint64, uint64, error) {
+	dataset, err := zfs.GetDataset(poolName)
+	if err != nil {
+		return 0, 0, 0, err
+	}
+
+	total := dataset.Used + dataset.Avail + dataset.Usedbydataset
+
+	return total, dataset.Avail, dataset.Avail, nil
+}
--- a/vendor/github.com/google/cadvisor/fs/test_resources/diskstats
+++ b/vendor/github.com/google/cadvisor/fs/test_resources/diskstats
@@ -0,0 +1,54 @@
+   1       0 ram0 0 0 0 0 0 0 0 0 0 0 0
+   1       1 ram1 0 0 0 0 0 0 0 0 0 0 0
+   1       2 ram2 0 0 0 0 0 0 0 0 0 0 0
+   1       3 ram3 0 0 0 0 0 0 0 0 0 0 0
+   1       4 ram4 0 0 0 0 0 0 0 0 0 0 0
+   1       5 ram5 0 0 0 0 0 0 0 0 0 0 0
+   1       6 ram6 0 0 0 0 0 0 0 0 0 0 0
+   1       7 ram7 0 0 0 0 0 0 0 0 0 0 0
+   1       8 ram8 0 0 0 0 0 0 0 0 0 0 0
+   1       9 ram9 0 0 0 0 0 0 0 0 0 0 0
+   1      10 ram10 0 0 0 0 0 0 0 0 0 0 0
+   1      11 ram11 0 0 0 0 0 0 0 0 0 0 0
+   1      12 ram12 0 0 0 0 0 0 0 0 0 0 0
+   1      13 ram13 0 0 0 0 0 0 0 0 0 0 0
+   1      14 ram14 0 0 0 0 0 0 0 0 0 0 0
+   1      15 ram15 0 0 0 0 0 0 0 0 0 0 0
+   7       0 loop0 0 0 0 0 0 0 0 0 0 0 0
+   7       1 loop1 0 0 0 0 0 0 0 0 0 0 0
+   7       2 loop2 0 0 0 0 0 0 0 0 0 0 0
+   7       3 loop3 0 0 0 0 0 0 0 0 0 0 0
+   7       4 loop4 0 0 0 0 0 0 0 0 0 0 0
+   7       5 loop5 0 0 0 0 0 0 0 0 0 0 0
+   7       6 loop6 0 0 0 0 0 0 0 0 0 0 0
+   7       7 loop7 0 0 0 0 0 0 0 0 0 0 0
+   8      16 sdb 931 1157 7601 960 2 0 16 0 0 919 960
+   8      17 sdb1 477 1147 3895 271 1 0 8 0 0 271 271
+   8      18 sdb2 395 0 3154 326 1 0 8 0 0 326 326
+   8       0 sda 931 1157 7601 1065 2 0 16 0 0 873 1065
+   8       1 sda1 477 1147 3895 419 1 0 8 0 0 419 419
+   8       2 sda2 395 0 3154 328 1 0 8 0 0 328 328
+   8      32 sdc 12390 470 457965 36363 72184 244851 9824537 5359169 0 607738 5437210
+   8      33 sdc1 10907 221 446193 34366 72173 244851 9824499 5359063 0 606972 5435214
+   8      34 sdc2 650 249 5120 901 7 0 22 93 0 956 994
+   8      35 sdc3 264 0 2106 380 1 0 8 0 0 380 380
+   8      36 sdc4 392 0 3130 476 1 0 8 0 0 475 475
+   8      48 sdd 3371 134 58909 18327 73997 243043 9824537 4532714 0 594248 4602162
+   8      49 sdd1 2498 134 51977 17192 73986 243043 9824499 4532600 0 593618 4600885
+   8      50 sdd2 40 0 280 223 7 0 22 108 0 330 330
+   8      51 sdd3 264 0 2106 328 1 0 8 0 0 328 328
+   8      52 sdd4 392 0 3130 373 1 0 8 1 0 374 374
+   8      64 sde 931 1157 7601 768 2 0 16 0 0 632 768
+   8      65 sde1 477 1147 3895 252 1 0 8 0 0 252 252
+   8      66 sde2 395 0 3154 281 1 0 8 0 0 281 281
+   8      80 sdf 931 1157 7601 936 2 0 16 0 0 717 936
+   8      81 sdf1 477 1147 3895 382 1 0 8 0 0 382 382
+   8      82 sdf2 395 0 3154 321 1 0 8 0 0 321 321
+   8      96 sdg 931 1157 7601 858 2 0 16 0 0 804 858
+   8      97 sdg1 477 1147 3895 244 1 0 8 0 0 244 244
+   8      98 sdg2 395 0 3154 299 1 0 8 0 0 299 299
+   8     112 sdh 931 1157 7601 895 2 0 16 0 0 841 895
+   8     113 sdh1 477 1147 3895 264 1 0 8 0 0 264 264
+   8     114 sdh2 395 0 3154 311 1 0 8 0 0 311 311
+ 252       0 dm-0 1251094 0 108121362 21287644 111848 0 52908472 22236936 0 4838500 43524784
+ 252       1 dm-1 58415638 0 2682446960 1719953592 20048040 0 543988240 1975572544 0 262085340 3695556828
--- a/vendor/github.com/google/cadvisor/fs/types.go
+++ b/vendor/github.com/google/cadvisor/fs/types.go
@@ -0,0 +1,83 @@
+// Copyright 2014 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 fs
+
+import "time"
+
+type DeviceInfo struct {
+	Device string
+	Major  uint
+	Minor  uint
+}
+
+type FsType string
+
+func (ft FsType) String() string {
+	return string(ft)
+}
+
+const (
+	ZFS          FsType = "zfs"
+	DeviceMapper FsType = "devicemapper"
+	VFS          FsType = "vfs"
+)
+
+type Fs struct {
+	DeviceInfo
+	Type       FsType
+	Capacity   uint64
+	Free       uint64
+	Available  uint64
+	Inodes     uint64
+	InodesFree uint64
+	DiskStats  DiskStats
+}
+
+type DiskStats struct {
+	ReadsCompleted  uint64
+	ReadsMerged     uint64
+	SectorsRead     uint64
+	ReadTime        uint64
+	WritesCompleted uint64
+	WritesMerged    uint64
+	SectorsWritten  uint64
+	WriteTime       uint64
+	IoInProgress    uint64
+	IoTime          uint64
+	WeightedIoTime  uint64
+}
+
+type FsInfo interface {
+	// Returns capacity and free space, in bytes, of all the ext2, ext3, ext4 filesystems on the host.
+	GetGlobalFsInfo() ([]Fs, error)
+
+	// Returns capacity and free space, in bytes, of the set of mounts passed.
+	GetFsInfoForPath(mountSet map[string]struct{}) ([]Fs, error)
+
+	// Returns number of bytes occupied by 'dir'.
+	GetDirUsage(dir string, timeout time.Duration) (uint64, error)
+
+	// Returns the block device info of the filesystem on which 'dir' resides.
+	GetDirFsDevice(dir string) (*DeviceInfo, error)
+
+	// Returns the device name associated with a particular label.
+	GetDeviceForLabel(label string) (string, error)
+
+	// Returns all labels associated with a particular device name.
+	GetLabelsForDevice(device string) ([]string, error)
+
+	// Returns the mountpoint associated with a particular device.
+	GetMountpointForDevice(device string) (string, error)
+}