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

vendor/github.com/google/cadvisor/cache/memory/memory.go

@@ -0,0 +1,139 @@
+// 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 memory
+
+import (
+	"fmt"
+	"sync"
+	"time"
+
+	info "github.com/google/cadvisor/info/v1"
+	"github.com/google/cadvisor/storage"
+	"github.com/google/cadvisor/utils"
+
+	"github.com/golang/glog"
+)
+
+// TODO(vmarmol): See about refactoring this class, we have an unecessary redirection of containerCache and InMemoryCache.
+// containerCache is used to store per-container information
+type containerCache struct {
+	ref         info.ContainerReference
+	recentStats *utils.TimedStore
+	maxAge      time.Duration
+	lock        sync.RWMutex
+}
+
+func (self *containerCache) AddStats(stats *info.ContainerStats) error {
+	self.lock.Lock()
+	defer self.lock.Unlock()
+
+	// Add the stat to storage.
+	self.recentStats.Add(stats.Timestamp, stats)
+	return nil
+}
+
+func (self *containerCache) RecentStats(start, end time.Time, maxStats int) ([]*info.ContainerStats, error) {
+	self.lock.RLock()
+	defer self.lock.RUnlock()
+	result := self.recentStats.InTimeRange(start, end, maxStats)
+	converted := make([]*info.ContainerStats, len(result))
+	for i, el := range result {
+		converted[i] = el.(*info.ContainerStats)
+	}
+	return converted, nil
+}
+
+func newContainerStore(ref info.ContainerReference, maxAge time.Duration) *containerCache {
+	return &containerCache{
+		ref:         ref,
+		recentStats: utils.NewTimedStore(maxAge, -1),
+		maxAge:      maxAge,
+	}
+}
+
+type InMemoryCache struct {
+	lock              sync.RWMutex
+	containerCacheMap map[string]*containerCache
+	maxAge            time.Duration
+	backend           storage.StorageDriver
+}
+
+func (self *InMemoryCache) AddStats(ref info.ContainerReference, stats *info.ContainerStats) error {
+	var cstore *containerCache
+	var ok bool
+
+	func() {
+		self.lock.Lock()
+		defer self.lock.Unlock()
+		if cstore, ok = self.containerCacheMap[ref.Name]; !ok {
+			cstore = newContainerStore(ref, self.maxAge)
+			self.containerCacheMap[ref.Name] = cstore
+		}
+	}()
+
+	if self.backend != nil {
+		// TODO(monnand): To deal with long delay write operations, we
+		// may want to start a pool of goroutines to do write
+		// operations.
+		if err := self.backend.AddStats(ref, stats); err != nil {
+			glog.Error(err)
+		}
+	}
+	return cstore.AddStats(stats)
+}
+
+func (self *InMemoryCache) RecentStats(name string, start, end time.Time, maxStats int) ([]*info.ContainerStats, error) {
+	var cstore *containerCache
+	var ok bool
+	err := func() error {
+		self.lock.RLock()
+		defer self.lock.RUnlock()
+		if cstore, ok = self.containerCacheMap[name]; !ok {
+			return fmt.Errorf("unable to find data for container %v", name)
+		}
+		return nil
+	}()
+	if err != nil {
+		return nil, err
+	}
+
+	return cstore.RecentStats(start, end, maxStats)
+}
+
+func (self *InMemoryCache) Close() error {
+	self.lock.Lock()
+	self.containerCacheMap = make(map[string]*containerCache, 32)
+	self.lock.Unlock()
+	return nil
+}
+
+func (self *InMemoryCache) RemoveContainer(containerName string) error {
+	self.lock.Lock()
+	delete(self.containerCacheMap, containerName)
+	self.lock.Unlock()
+	return nil
+}
+
+func New(
+	maxAge time.Duration,
+	backend storage.StorageDriver,
+) *InMemoryCache {
+	ret := &InMemoryCache{
+		containerCacheMap: make(map[string]*containerCache, 32),
+		maxAge:            maxAge,
+		backend:           backend,
+	}
+	return ret
+}