Bump cAdvisor (and dependencies) godeps version

vendor/github.com/google/cadvisor/manager/watcher/raw/raw.go

@@ -0,0 +1,214 @@
+// 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 container defines types for sub-container events and also
+// defines an interface for container operation handlers.
+package raw
+
+import (
+	"fmt"
+	"io/ioutil"
+	"path"
+	"strings"
+
+	"github.com/google/cadvisor/container/common"
+	"github.com/google/cadvisor/container/libcontainer"
+	"github.com/google/cadvisor/manager/watcher"
+
+	"github.com/golang/glog"
+	"golang.org/x/exp/inotify"
+)
+
+type rawContainerWatcher struct {
+	// Absolute path to the root of the cgroup hierarchies
+	cgroupPaths map[string]string
+
+	cgroupSubsystems *libcontainer.CgroupSubsystems
+
+	// Inotify event watcher.
+	watcher *common.InotifyWatcher
+
+	// Signal for watcher thread to stop.
+	stopWatcher chan error
+}
+
+func NewRawContainerWatcher() (watcher.ContainerWatcher, error) {
+	cgroupSubsystems, err := libcontainer.GetCgroupSubsystems()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get cgroup subsystems: %v", err)
+	}
+	if len(cgroupSubsystems.Mounts) == 0 {
+		return nil, fmt.Errorf("failed to find supported cgroup mounts for the raw factory")
+	}
+
+	watcher, err := common.NewInotifyWatcher()
+	if err != nil {
+		return nil, err
+	}
+
+	rawWatcher := &rawContainerWatcher{
+		cgroupPaths:      common.MakeCgroupPaths(cgroupSubsystems.MountPoints, "/"),
+		cgroupSubsystems: &cgroupSubsystems,
+		watcher:          watcher,
+		stopWatcher:      make(chan error),
+	}
+
+	return rawWatcher, nil
+}
+
+func (self *rawContainerWatcher) Start(events chan watcher.ContainerEvent) error {
+	// Watch this container (all its cgroups) and all subdirectories.
+	for _, cgroupPath := range self.cgroupPaths {
+		_, err := self.watchDirectory(cgroupPath, "/")
+		if err != nil {
+			return err
+		}
+	}
+
+	// Process the events received from the kernel.
+	go func() {
+		for {
+			select {
+			case event := <-self.watcher.Event():
+				err := self.processEvent(event, events)
+				if err != nil {
+					glog.Warningf("Error while processing event (%+v): %v", event, err)
+				}
+			case err := <-self.watcher.Error():
+				glog.Warningf("Error while watching %q:", "/", err)
+			case <-self.stopWatcher:
+				err := self.watcher.Close()
+				if err == nil {
+					self.stopWatcher <- err
+					return
+				}
+			}
+		}
+	}()
+
+	return nil
+}
+
+func (self *rawContainerWatcher) Stop() error {
+	// Rendezvous with the watcher thread.
+	self.stopWatcher <- nil
+	return <-self.stopWatcher
+}
+
+// Watches the specified directory and all subdirectories. Returns whether the path was
+// already being watched and an error (if any).
+func (self *rawContainerWatcher) watchDirectory(dir string, containerName string) (bool, error) {
+	alreadyWatching, err := self.watcher.AddWatch(containerName, dir)
+	if err != nil {
+		return alreadyWatching, err
+	}
+
+	// Remove the watch if further operations failed.
+	cleanup := true
+	defer func() {
+		if cleanup {
+			_, err := self.watcher.RemoveWatch(containerName, dir)
+			if err != nil {
+				glog.Warningf("Failed to remove inotify watch for %q: %v", dir, err)
+			}
+		}
+	}()
+
+	// TODO(vmarmol): We should re-do this once we're done to ensure directories were not added in the meantime.
+	// Watch subdirectories as well.
+	entries, err := ioutil.ReadDir(dir)
+	if err != nil {
+		return alreadyWatching, err
+	}
+	for _, entry := range entries {
+		if entry.IsDir() {
+			// TODO(vmarmol): We don't have to fail here, maybe we can recover and try to get as many registrations as we can.
+			_, err = self.watchDirectory(path.Join(dir, entry.Name()), path.Join(containerName, entry.Name()))
+			if err != nil {
+				return alreadyWatching, err
+			}
+		}
+	}
+
+	cleanup = false
+	return alreadyWatching, nil
+}
+
+func (self *rawContainerWatcher) processEvent(event *inotify.Event, events chan watcher.ContainerEvent) error {
+	// Convert the inotify event type to a container create or delete.
+	var eventType watcher.ContainerEventType
+	switch {
+	case (event.Mask & inotify.IN_CREATE) > 0:
+		eventType = watcher.ContainerAdd
+	case (event.Mask & inotify.IN_DELETE) > 0:
+		eventType = watcher.ContainerDelete
+	case (event.Mask & inotify.IN_MOVED_FROM) > 0:
+		eventType = watcher.ContainerDelete
+	case (event.Mask & inotify.IN_MOVED_TO) > 0:
+		eventType = watcher.ContainerAdd
+	default:
+		// Ignore other events.
+		return nil
+	}
+
+	// Derive the container name from the path name.
+	var containerName string
+	for _, mount := range self.cgroupSubsystems.Mounts {
+		mountLocation := path.Clean(mount.Mountpoint) + "/"
+		if strings.HasPrefix(event.Name, mountLocation) {
+			containerName = event.Name[len(mountLocation)-1:]
+			break
+		}
+	}
+	if containerName == "" {
+		return fmt.Errorf("unable to detect container from watch event on directory %q", event.Name)
+	}
+
+	// Maintain the watch for the new or deleted container.
+	switch eventType {
+	case watcher.ContainerAdd:
+		// New container was created, watch it.
+		alreadyWatched, err := self.watchDirectory(event.Name, containerName)
+		if err != nil {
+			return err
+		}
+
+		// Only report container creation once.
+		if alreadyWatched {
+			return nil
+		}
+	case watcher.ContainerDelete:
+		// Container was deleted, stop watching for it.
+		lastWatched, err := self.watcher.RemoveWatch(containerName, event.Name)
+		if err != nil {
+			return err
+		}
+
+		// Only report container deletion once.
+		if !lastWatched {
+			return nil
+		}
+	default:
+		return fmt.Errorf("unknown event type %v", eventType)
+	}
+
+	// Deliver the event.
+	events <- watcher.ContainerEvent{
+		EventType:   eventType,
+		Name:        containerName,
+		WatchSource: watcher.Raw,
+	}
+
+	return nil
+}

vendor/github.com/google/cadvisor/manager/watcher/rkt/rkt.go

@@ -0,0 +1,154 @@
+// 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 rkt implements the watcher interface for rkt
+package rkt
+
+import (
+	"path/filepath"
+	"time"
+
+	"github.com/google/cadvisor/container/rkt"
+	"github.com/google/cadvisor/manager/watcher"
+
+	rktapi "github.com/coreos/rkt/api/v1alpha"
+	"github.com/golang/glog"
+	"golang.org/x/net/context"
+)
+
+type rktContainerWatcher struct {
+	// Signal for watcher thread to stop.
+	stopWatcher chan error
+}
+
+func NewRktContainerWatcher() (watcher.ContainerWatcher, error) {
+	watcher := &rktContainerWatcher{
+		stopWatcher: make(chan error),
+	}
+
+	return watcher, nil
+}
+
+func (self *rktContainerWatcher) Start(events chan watcher.ContainerEvent) error {
+	go self.detectRktContainers(events)
+
+	return nil
+}
+
+func (self *rktContainerWatcher) Stop() error {
+	// Rendezvous with the watcher thread.
+	self.stopWatcher <- nil
+	return nil
+}
+
+func (self *rktContainerWatcher) detectRktContainers(events chan watcher.ContainerEvent) {
+	glog.Infof("starting detectRktContainers thread")
+	ticker := time.Tick(10 * time.Second)
+	curpods := make(map[string]*rktapi.Pod)
+
+	for {
+		select {
+		case <-ticker:
+			pods, err := listRunningPods()
+			if err != nil {
+				glog.Errorf("detectRktContainers: listRunningPods failed: %v", err)
+				continue
+			}
+			curpods = self.syncRunningPods(pods, events, curpods)
+
+		case <-self.stopWatcher:
+			glog.Infof("Exiting rktContainer Thread")
+			return
+		}
+	}
+}
+
+func (self *rktContainerWatcher) syncRunningPods(pods []*rktapi.Pod, events chan watcher.ContainerEvent, curpods map[string]*rktapi.Pod) map[string]*rktapi.Pod {
+	newpods := make(map[string]*rktapi.Pod)
+
+	for _, pod := range pods {
+		newpods[pod.Id] = pod
+		// if pods become mutable, have to handle this better
+		if _, ok := curpods[pod.Id]; !ok {
+			// should create all cgroups not including system.slice
+			// i.e. /system.slice/rkt-test.service and /system.slice/rkt-test.service/system.slice/pause.service
+			for _, cgroup := range podToCgroup(pod) {
+				self.sendUpdateEvent(cgroup, events)
+			}
+		}
+	}
+
+	for id, pod := range curpods {
+		if _, ok := newpods[id]; !ok {
+			for _, cgroup := range podToCgroup(pod) {
+				glog.Infof("cgroup to delete = %v", cgroup)
+				self.sendDestroyEvent(cgroup, events)
+			}
+		}
+	}
+
+	return newpods
+}
+
+func (self *rktContainerWatcher) sendUpdateEvent(cgroup string, events chan watcher.ContainerEvent) {
+	events <- watcher.ContainerEvent{
+		EventType:   watcher.ContainerAdd,
+		Name:        cgroup,
+		WatchSource: watcher.Rkt,
+	}
+}
+
+func (self *rktContainerWatcher) sendDestroyEvent(cgroup string, events chan watcher.ContainerEvent) {
+	events <- watcher.ContainerEvent{
+		EventType:   watcher.ContainerDelete,
+		Name:        cgroup,
+		WatchSource: watcher.Rkt,
+	}
+}
+
+func listRunningPods() ([]*rktapi.Pod, error) {
+	client, err := rkt.Client()
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := client.ListPods(context.Background(), &rktapi.ListPodsRequest{
+		// Specify the request: Fetch and print only running pods and their details.
+		Detail: true,
+		Filters: []*rktapi.PodFilter{
+			{
+				States: []rktapi.PodState{rktapi.PodState_POD_STATE_RUNNING},
+			},
+		},
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return resp.Pods, nil
+}
+
+func podToCgroup(pod *rktapi.Pod) []string {
+	cgroups := make([]string, 1+len(pod.Apps), 1+len(pod.Apps))
+
+	baseCgroup := pod.Cgroup
+	cgroups[0] = baseCgroup
+
+	for i, app := range pod.Apps {
+		cgroups[i+1] = filepath.Join(baseCgroup, "system.slice", app.Name+".service")
+	}
+
+	return cgroups
+}

vendor/github.com/google/cadvisor/manager/watcher/watcher.go

@@ -0,0 +1,52 @@
+// 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 container defines types for sub-container events and also
+// defines an interface for container operation handlers.
+package watcher
+
+// SubcontainerEventType indicates an addition or deletion event.
+type ContainerEventType int
+
+const (
+	ContainerAdd ContainerEventType = iota
+	ContainerDelete
+)
+
+type ContainerWatchSource int
+
+const (
+	Raw ContainerWatchSource = iota
+	Rkt
+)
+
+// ContainerEvent represents a
+type ContainerEvent struct {
+	// The type of event that occurred.
+	EventType ContainerEventType
+
+	// The full container name of the container where the event occurred.
+	Name string
+
+	// The watcher that detected this change event
+	WatchSource ContainerWatchSource
+}
+
+type ContainerWatcher interface {
+	// Registers a channel to listen for events affecting subcontainers (recursively).
+	Start(events chan ContainerEvent) error
+
+	// Stops watching for subcontainer changes.
+	Stop() error
+}