Add cAdvisor into third_party

third_party/deps.sh

@@ -12,6 +12,7 @@ DEP_PACKAGES="
   code.google.com/p/google-api-go-client/googleapi
   github.com/coreos/go-log/log
   github.com/coreos/go-systemd/journal
+  github.com/google/cadvisor/info
 "
 
 PACKAGES="$TOP_PACKAGES $DEP_PACKAGES"

third_party/src/github.com/google/cadvisor/.travis.yml

@@ -0,0 +1,13 @@
+language: go
+go:
+ - 1.2
+before_script:
+ - go get github.com/stretchr/testify/mock
+ - go get github.com/kr/pretty
+script:
+ - go test -v -race github.com/google/cadvisor/container
+ - go test -v github.com/google/cadvisor/info
+ - go test -v github.com/google/cadvisor/client
+ - go test -v github.com/google/cadvisor/sampling
+ - go test -v github.com/google/cadvisor/storage/memory
+ - go build github.com/google/cadvisor

third_party/src/github.com/google/cadvisor/AUTHORS

@@ -0,0 +1,11 @@
+# This is the official list of cAdvisor authors for copyright purposes.
+# This file is distinct from the CONTRIBUTORS files.
+# See the latter for an explanation.
+
+# Names should be added to this file as
+#     Name or Organization <email address>
+# The email address is not required for organizations.
+
+# Please keep the list sorted.
+
+Google Inc.

third_party/src/github.com/google/cadvisor/CONTRIBUTING.md

@@ -0,0 +1,14 @@
+## How to contribute
+
+Open an issue or a pull request, its that easy!
+
+## Contributor License Agreements
+
+We'd love to accept your pull requests! Before we can merge them, we have to jump a couple of legal hurdles.
+
+Please fill out either the individual or corporate Contributor License Agreement (CLA).
+
+  * If you are an individual writing original source code and you're sure you own the intellectual property, then you'll need to sign an [individual CLA](http://code.google.com/legal/individual-cla-v1.0.html).
+  * If you work for a company that wants to allow you to contribute your work, then you'll need to sign a [corporate CLA](http://code.google.com/legal/corporate-cla-v1.0.html).
+
+Follow either of the two links above to access the appropriate CLA and instructions for how to sign and return it. Once we receive it, we'll be able to accept your pull requests.

third_party/src/github.com/google/cadvisor/CONTRIBUTORS

@@ -0,0 +1,11 @@
+# This is the official list of people who have contributed to the project. The
+# copyright is held by those individuals or organizations in the AUTHORS file.
+#
+# Names should be added to this file like so:
+#     Name <email address>
+
+# Please keep the list sorted by first name.
+
+Kamil Yurtsever <kyurtsever@google.com>
+Nan Deng <dengnan@google.com>
+Victor Marmol <vmarmol@google.com>

third_party/src/github.com/google/cadvisor/Dockerfile

@@ -0,0 +1,16 @@
+FROM google/golang-runtime
+MAINTAINER dengnan@google.com vmarmol@google.com proppy@google.com
+
+# TODO(vmarmol): Build from source.
+# Get lmctfy and its dependencies.
+RUN apt-get update -y --force-yes &&  apt-get install -y --no-install-recommends --force-yes pkg-config libapparmor1
+ADD http://storage.googleapis.com/cadvisor-bin/lmctfy/libre2.so.0.0.0 /usr/lib/libre2.so.0
+ADD http://storage.googleapis.com/cadvisor-bin/lmctfy/lmctfy /usr/bin/lmctfy
+RUN chmod +x /usr/bin/lmctfy
+
+# Install libprotobuf8.
+ADD http://storage.googleapis.com/cadvisor-bin/lmctfy/libprotobuf8_2.5.0-9_amd64.deb /tmp/libprotobuf8_2.5.0-9_amd64.deb
+ADD http://storage.googleapis.com/cadvisor-bin/lmctfy/libc6_2.19-1_amd64.deb /tmp/libc6_2.19-1_amd64.deb
+RUN dpkg -i /tmp/libc6_2.19-1_amd64.deb /tmp/libprotobuf8_2.5.0-9_amd64.deb
+
+# The image builds the app and exposes it on 8080.

third_party/src/github.com/google/cadvisor/LICENSE

@@ -0,0 +1,190 @@
+   Copyright 2014 The cAdvisor 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.
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS

third_party/src/github.com/google/cadvisor/README.md

@@ -0,0 +1,93 @@
+# cAdvisor
+
+cAdvisor (Container Advisor) provides container users an understanding of the resource usage and performance characteristics of their running containers. It is a running daemon that collects, aggregates, processes, and exports information about running containers. Specifically, for each container it keeps resource isolation parameters, historical resource usage, and histograms of complete historical resource usage. This data is exported by container and machine-wide.
+
+cAdvisor currently supports lmctfy containers as well as Docker containers (those that use the default libcontainer execdriver). Other container backends can also be added. cAdvisor's container abstraction is based on lmctfy's so containers are inherently nested hierarchically.
+
+![cAdvisor](logo.png "cAdvisor")
+
+#### Quick Start: Running cAdvisor in a Docker Container
+
+To quickly tryout cAdvisor on your machine with Docker (version 0.11 or above), we have a Docker image that includes everything you need to get started. Simply run:
+
+```
+sudo docker run \
+  --volume=/var/run:/var/run:rw \
+  --volume=/sys/fs/cgroup/:/sys/fs/cgroup:ro \
+  --volume=/var/lib/docker/:/var/lib/docker:ro \
+  --publish=8080:8080 \
+  --detach=true \
+  google/cadvisor
+```
+
+cAdvisor is now running (in the background) on `http://localhost:8080`. The setup includes directories with Docker state cAdvisor needs to observe.
+
+If you want to build your own cAdvisor Docker image, take a look at the Dockerfile which can build a cAdvisor docker container under `quickstart/Dockerfile`.
+
+## Web UI
+
+cAdvisor exposes a web UI at its port:
+
+`http://<hostname>:<port>/`
+
+## Remote REST API
+
+cAdvisor exposes its raw and processed stats via a versioned remote REST API:
+
+`http://<hostname>:<port>/api/<version>/<request>`
+
+The current (and only) version of the API is `v1.0`.
+
+### Version 1.0
+
+This version exposes two main endpoints, one for container information and the other for machine information. Both endpoints are read-only in v1.0.
+
+#### Container Information
+
+The resource name for container information is as follows:
+
+`/api/v1.0/containers/<absolute container name>`
+
+Where the absolute container name follows the lmctfy naming convention. For example:
+
+| Container Name       | Resource Name                             |
+|----------------------|-------------------------------------------|
+| /                    | /api/v1.0/containers/                     |
+| /foo                 | /api/v1.0/containers/foo                  |
+| /docker/2c4dee605d22 | /api/v1.0/containers/docker/2c4dee605d22  |
+
+Note that the root container (`/`) contains usage for the entire machine. All Docker containers are listed under `/docker`.
+
+The container information is returned as a JSON object containing:
+
+- Absolute container name
+- List of subcontainers
+- ContainerSpec which describes the resource isolation enabled in the container
+- Detailed resource usage statistics of the container for the last `N` seconds (`N` is globally configurable in cAdvisor)
+- Histogram of resource usage from the creation of the container
+
+The actual object is the marshalled JSON of the `ContainerInfo` struct found in [info/container.go](info/container.go)
+
+#### Machine Information
+
+The resource name for machine information is as follows:
+
+`/api/v1.0/machine`
+
+This resource is read-only. The machine information is returned as a JSON object containing:
+
+- Number of schedulable logical CPU cores
+- Memory capacity (in bytes)
+
+The actual object is the marshalled JSON of the `MachineInfo` struct found in [info/machine.go](info/machine.go)
+
+## Roadmap
+
+cAdvisor aims to improve the resource usage and performance characteristics of running containers. Today, we gather and expose this information to users. In our roadmap:
+- Advise on the performance of a container (e.g.: when it is being negatively affected by another, when it is not receiving the resources it requires, etc)
+- Auto-tune the performance of the container based on previous advise.
+- Provide usage prediction to cluster schedulers and orchestration layers.
+
+## Community
+
+Contributions, questions, and comments are all welcomed and encouraged! cAdvisor developers hand out in [#google-containers](http://webchat.freenode.net/?channels=google-containers) room on freenode.net.  We also have the [google-containers Google Groups mailing list](https://groups.google.com/forum/#!forum/google-containers).

third_party/src/github.com/google/cadvisor/TODO.txt

@@ -0,0 +1,2 @@
+- Allow us to have different tracking policies: only top-level, only specified, all containers
+- Add ability to checkpoint state (and plugable medium for this)

third_party/src/github.com/google/cadvisor/api/handler.go

@@ -0,0 +1,88 @@
+// 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.
+
+// Handler for /api/
+
+package api
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	"github.com/google/cadvisor/manager"
+)
+
+const (
+	ApiResource   = "/api/v1.0/"
+	ContainersApi = "containers"
+	MachineApi    = "machine"
+)
+
+func HandleRequest(m manager.Manager, w http.ResponseWriter, u *url.URL) error {
+	start := time.Now()
+
+	// Get API request type.
+	requestType := u.Path[len(ApiResource):]
+	i := strings.Index(requestType, "/")
+	requestArgs := ""
+	if i != -1 {
+		requestArgs = requestType[i:]
+		requestType = requestType[:i]
+	}
+
+	if requestType == MachineApi {
+		log.Printf("Api - Machine")
+
+		// Get the MachineInfo
+		machineInfo, err := m.GetMachineInfo()
+		if err != nil {
+			return err
+		}
+
+		out, err := json.Marshal(machineInfo)
+		if err != nil {
+			fmt.Fprintf(w, "Failed to marshall MachineInfo with error: %s", err)
+		}
+		w.Write(out)
+	} else if requestType == ContainersApi {
+		// The container name is the path after the requestType
+		containerName := requestArgs
+
+		log.Printf("Api - Container(%s)", containerName)
+
+		// Get the container.
+		cont, err := m.GetContainerInfo(containerName)
+		if err != nil {
+			fmt.Fprintf(w, "Failed to get container \"%s\" with error: %s", containerName, err)
+			return err
+		}
+
+		// Only output the container as JSON.
+		out, err := json.Marshal(cont)
+		if err != nil {
+			fmt.Fprintf(w, "Failed to marshall container %q with error: %s", containerName, err)
+		}
+		w.Write(out)
+	} else {
+		return fmt.Errorf("unknown API request type %q", requestType)
+	}
+
+	log.Printf("Request took %s", time.Since(start))
+	return nil
+}

third_party/src/github.com/google/cadvisor/cadvisor.go

@@ -0,0 +1,96 @@
+// 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 main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+	"net/http"
+
+	"github.com/google/cadvisor/api"
+	"github.com/google/cadvisor/container/docker"
+	"github.com/google/cadvisor/container/lmctfy"
+	"github.com/google/cadvisor/info"
+	"github.com/google/cadvisor/manager"
+	"github.com/google/cadvisor/pages"
+	"github.com/google/cadvisor/pages/static"
+	"github.com/google/cadvisor/storage/memory"
+)
+
+var argPort = flag.Int("port", 8080, "port to listen")
+var argSampleSize = flag.Int("samples", 1024, "number of samples we want to keep")
+var argHistoryDuration = flag.Int("history_duration", 60, "number of seconds of container history to keep")
+
+func main() {
+	flag.Parse()
+
+	storage := memory.New(*argSampleSize, *argHistoryDuration)
+	// TODO(monnand): Add stats writer for manager
+	containerManager, err := manager.New(storage)
+	if err != nil {
+		log.Fatalf("Failed to create a Container Manager: %s", err)
+	}
+
+	if err := lmctfy.Register("/"); err != nil {
+		log.Printf("lmctfy registration failed: %v.", err)
+		log.Print("Running in docker only mode.")
+		if err := docker.Register(containerManager, "/"); err != nil {
+			log.Printf("Docker registration failed: %v.", err)
+			log.Fatalf("Unable to continue without docker or lmctfy.")
+		}
+	}
+
+	if err := docker.Register(containerManager, "/docker"); err != nil {
+		// Ignore this error because we should work with lmctfy only
+		log.Printf("Docker registration failed: %v.", err)
+		log.Print("Running in lmctfy only mode.")
+	}
+
+	// Handler for static content.
+	http.HandleFunc(static.StaticResource, func(w http.ResponseWriter, r *http.Request) {
+		err := static.HandleRequest(w, r.URL)
+		if err != nil {
+			fmt.Fprintf(w, "%s", err)
+		}
+	})
+
+	// Handler for the API.
+	http.HandleFunc(api.ApiResource, func(w http.ResponseWriter, r *http.Request) {
+		err := api.HandleRequest(containerManager, w, r.URL)
+		if err != nil {
+			fmt.Fprintf(w, "%s", err)
+		}
+	})
+
+	// Redirect / to containers page.
+	http.Handle("/", http.RedirectHandler(pages.ContainersPage, http.StatusTemporaryRedirect))
+
+	// Register the handler for the containers page.
+	http.HandleFunc(pages.ContainersPage, func(w http.ResponseWriter, r *http.Request) {
+		err := pages.ServerContainersPage(containerManager, w, r.URL)
+		if err != nil {
+			fmt.Fprintf(w, "%s", err)
+		}
+	})
+
+	go containerManager.Start()
+
+	log.Printf("Starting cAdvisor version: %q", info.VERSION)
+	log.Print("About to serve on port ", *argPort)
+
+	addr := fmt.Sprintf(":%v", *argPort)
+	log.Fatal(http.ListenAndServe(addr, nil))
+}

third_party/src/github.com/google/cadvisor/client/client.go

@@ -0,0 +1,96 @@
+// 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 cadvisor
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"strings"
+
+	"github.com/google/cadvisor/info"
+)
+
+type Client struct {
+	baseUrl string
+}
+
+func NewClient(URL string) (*Client, error) {
+	c := &Client{
+		baseUrl: strings.Join([]string{
+			URL,
+			"api/v1.0",
+		}, "/"),
+	}
+	_, err := c.MachineInfo()
+	if err != nil {
+		return nil, err
+	}
+	return c, nil
+}
+
+func (self *Client) machineInfoUrl() string {
+	return strings.Join([]string{self.baseUrl, "machine"}, "/")
+}
+
+func (self *Client) MachineInfo() (minfo *info.MachineInfo, err error) {
+	u := self.machineInfoUrl()
+	ret := new(info.MachineInfo)
+	err = self.httpGetJsonData(ret, u, "machine info")
+	if err != nil {
+		return
+	}
+	minfo = ret
+	return
+}
+
+func (self *Client) containerInfoUrl(name string) string {
+	if name[0] == '/' {
+		name = name[1:]
+	}
+	return strings.Join([]string{self.baseUrl, "containers", name}, "/")
+}
+
+func (self *Client) httpGetJsonData(data interface{}, url, infoName string) error {
+	resp, err := http.Get(url)
+	if err != nil {
+		err = fmt.Errorf("unable to get %v: %v", infoName, err)
+		return err
+	}
+	defer resp.Body.Close()
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		err = fmt.Errorf("unable to read all %v: %v", infoName, err)
+		return err
+	}
+	err = json.Unmarshal(body, data)
+	if err != nil {
+		err = fmt.Errorf("unable to unmarshal %v (%v): %v", infoName, string(body), err)
+		return err
+	}
+	return nil
+}
+
+func (self *Client) ContainerInfo(name string) (cinfo *info.ContainerInfo, err error) {
+	u := self.containerInfoUrl(name)
+	ret := new(info.ContainerInfo)
+	err = self.httpGetJsonData(ret, u, fmt.Sprintf("container info for %v", name))
+	if err != nil {
+		return
+	}
+	cinfo = ret
+	return
+}

third_party/src/github.com/google/cadvisor/client/client_test.go

@@ -0,0 +1,756 @@
+// 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 cadvisor
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"reflect"
+	"testing"
+
+	"github.com/google/cadvisor/info"
+)
+
+func testGetJsonData(
+	strRep string,
+	emptyData interface{},
+	f func() (interface{}, error),
+) error {
+	err := json.Unmarshal([]byte(strRep), emptyData)
+	if err != nil {
+		return fmt.Errorf("invalid json input: %v", err)
+	}
+	reply, err := f()
+	if err != nil {
+		return fmt.Errorf("unable to retrieve data: %v", err)
+	}
+	if !reflect.DeepEqual(reply, emptyData) {
+		return fmt.Errorf("retrieved wrong data: %+v != %+v", reply, emptyData)
+	}
+	return nil
+}
+
+func cadvisorTestClient(path, reply string) (*Client, *httptest.Server, error) {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path == path {
+			fmt.Fprint(w, reply)
+		} else if r.URL.Path == "/api/v1.0/machine" {
+			fmt.Fprint(w, `{"num_cores":8,"memory_capacity":31625871360}`)
+		} else {
+			w.WriteHeader(http.StatusNotFound)
+			fmt.Fprintf(w, "Page not found.")
+		}
+	}))
+	client, err := NewClient(ts.URL)
+	if err != nil {
+		ts.Close()
+		return nil, nil, err
+	}
+	return client, ts, err
+}
+
+func TestGetMachineinfo(t *testing.T) {
+	respStr := `{"num_cores":8,"memory_capacity":31625871360}`
+	client, server, err := cadvisorTestClient("/api/v1.0/machine", respStr)
+	if err != nil {
+		t.Fatalf("unable to get a client %v", err)
+	}
+	defer server.Close()
+	err = testGetJsonData(respStr, &info.MachineInfo{}, func() (interface{}, error) {
+		return client.MachineInfo()
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestGetContainerInfo(t *testing.T) {
+	respStr := `
+{
+  "name": "%v",
+  "spec": {
+    "cpu": {
+      "limit": 18446744073709551000,
+      "max_limit": 0,
+      "mask": {
+        "data": [
+          18446744073709551000
+        ]
+      }
+    },
+    "memory": {
+      "limit": 18446744073709551000,
+      "swap_limit": 18446744073709551000
+    }
+  },
+  "stats": [
+    {
+      "timestamp": "2014-06-13T01:03:26.434981825Z",
+      "cpu": {
+        "usage": {
+          "total": 56896502,
+          "per_cpu": [
+            20479682,
+            13579420,
+            6025040,
+            2255123,
+            3635661,
+            2489368,
+            5158288,
+            3273920
+          ],
+          "user": 10000000,
+          "system": 30000000
+        },
+        "load": 0
+      },
+      "memory": {
+        "usage": 495616,
+        "container_data": {
+          "pgfault": 2279
+        },
+        "hierarchical_data": {
+          "pgfault": 2279
+        }
+      }
+    },
+    {
+      "timestamp": "2014-06-13T01:03:27.538394608Z",
+      "cpu": {
+        "usage": {
+          "total": 56896502,
+          "per_cpu": [
+            20479682,
+            13579420,
+            6025040,
+            2255123,
+            3635661,
+            2489368,
+            5158288,
+            3273920
+          ],
+          "user": 10000000,
+          "system": 30000000
+        },
+        "load": 0
+      },
+      "memory": {
+        "usage": 495616,
+        "container_data": {
+          "pgfault": 2279
+        },
+        "hierarchical_data": {
+          "pgfault": 2279
+        }
+      }
+    },
+    {
+      "timestamp": "2014-06-13T01:03:28.640302072Z",
+      "cpu": {
+        "usage": {
+          "total": 56896502,
+          "per_cpu": [
+            20479682,
+            13579420,
+            6025040,
+            2255123,
+            3635661,
+            2489368,
+            5158288,
+            3273920
+          ],
+          "user": 10000000,
+          "system": 30000000
+        },
+        "load": 0
+      },
+      "memory": {
+        "usage": 495616,
+        "container_data": {
+          "pgfault": 2279
+        },
+        "hierarchical_data": {
+          "pgfault": 2279
+        }
+      }
+    },
+    {
+      "timestamp": "2014-06-13T01:03:29.74247308Z",
+      "cpu": {
+        "usage": {
+          "total": 56896502,
+          "per_cpu": [
+            20479682,
+            13579420,
+            6025040,
+            2255123,
+            3635661,
+            2489368,
+            5158288,
+            3273920
+          ],
+          "user": 10000000,
+          "system": 30000000
+        },
+        "load": 0
+      },
+      "memory": {
+        "usage": 495616,
+        "container_data": {
+          "pgfault": 2279
+        },
+        "hierarchical_data": {
+          "pgfault": 2279
+        }
+      }
+    },
+    {
+      "timestamp": "2014-06-13T01:03:30.844494537Z",
+      "cpu": {
+        "usage": {
+          "total": 56896502,
+          "per_cpu": [
+            20479682,
+            13579420,
+            6025040,
+            2255123,
+            3635661,
+            2489368,
+            5158288,
+            3273920
+          ],
+          "user": 10000000,
+          "system": 30000000
+        },
+        "load": 0
+      },
+      "memory": {
+        "usage": 495616,
+        "container_data": {
+          "pgfault": 2279
+        },
+        "hierarchical_data": {
+          "pgfault": 2279
+        }
+      }
+    },
+    {
+      "timestamp": "2014-06-13T01:03:31.946757066Z",
+      "cpu": {
+        "usage": {
+          "total": 56896502,
+          "per_cpu": [
+            20479682,
+            13579420,
+            6025040,
+            2255123,
+            3635661,
+            2489368,
+            5158288,
+            3273920
+          ],
+          "user": 10000000,
+          "system": 30000000
+        },
+        "load": 0
+      },
+      "memory": {
+        "usage": 495616,
+        "container_data": {
+          "pgfault": 2279
+        },
+        "hierarchical_data": {
+          "pgfault": 2279
+        }
+      }
+    },
+    {
+      "timestamp": "2014-06-13T01:03:33.050214062Z",
+      "cpu": {
+        "usage": {
+          "total": 56896502,
+          "per_cpu": [
+            20479682,
+            13579420,
+            6025040,
+            2255123,
+            3635661,
+            2489368,
+            5158288,
+            3273920
+          ],
+          "user": 10000000,
+          "system": 30000000
+        },
+        "load": 0
+      },
+      "memory": {
+        "usage": 495616,
+        "container_data": {
+          "pgfault": 2279
+        },
+        "hierarchical_data": {
+          "pgfault": 2279
+        }
+      }
+    },
+    {
+      "timestamp": "2014-06-13T01:03:34.15222186Z",
+      "cpu": {
+        "usage": {
+          "total": 56896502,
+          "per_cpu": [
+            20479682,
+            13579420,
+            6025040,
+            2255123,
+            3635661,
+            2489368,
+            5158288,
+            3273920
+          ],
+          "user": 10000000,
+          "system": 30000000
+        },
+        "load": 0
+      },
+      "memory": {
+        "usage": 495616,
+        "container_data": {
+          "pgfault": 2279
+        },
+        "hierarchical_data": {
+          "pgfault": 2279
+        }
+      }
+    },
+    {
+      "timestamp": "2014-06-13T01:03:35.25417391Z",
+      "cpu": {
+        "usage": {
+          "total": 56896502,
+          "per_cpu": [
+            20479682,
+            13579420,
+            6025040,
+            2255123,
+            3635661,
+            2489368,
+            5158288,
+            3273920
+          ],
+          "user": 10000000,
+          "system": 30000000
+        },
+        "load": 0
+      },
+      "memory": {
+        "usage": 495616,
+        "container_data": {
+          "pgfault": 2279
+        },
+        "hierarchical_data": {
+          "pgfault": 2279
+        }
+      }
+    },
+    {
+      "timestamp": "2014-06-13T01:03:36.355902169Z",
+      "cpu": {
+        "usage": {
+          "total": 56896502,
+          "per_cpu": [
+            20479682,
+            13579420,
+            6025040,
+            2255123,
+            3635661,
+            2489368,
+            5158288,
+            3273920
+          ],
+          "user": 10000000,
+          "system": 30000000
+        },
+        "load": 0
+      },
+      "memory": {
+        "usage": 495616,
+        "container_data": {
+          "pgfault": 2279
+        },
+        "hierarchical_data": {
+          "pgfault": 2279
+        }
+      }
+    },
+    {
+      "timestamp": "2014-06-13T01:03:37.457585928Z",
+      "cpu": {
+        "usage": {
+          "total": 56896502,
+          "per_cpu": [
+            20479682,
+            13579420,
+            6025040,
+            2255123,
+            3635661,
+            2489368,
+            5158288,
+            3273920
+          ],
+          "user": 10000000,
+          "system": 30000000
+        },
+        "load": 0
+      },
+      "memory": {
+        "usage": 495616,
+        "container_data": {
+          "pgfault": 2279
+        },
+        "hierarchical_data": {
+          "pgfault": 2279
+        }
+      }
+    },
+    {
+      "timestamp": "2014-06-13T01:03:38.559417379Z",
+      "cpu": {
+        "usage": {
+          "total": 56896502,
+          "per_cpu": [
+            20479682,
+            13579420,
+            6025040,
+            2255123,
+            3635661,
+            2489368,
+            5158288,
+            3273920
+          ],
+          "user": 10000000,
+          "system": 30000000
+        },
+        "load": 0
+      },
+      "memory": {
+        "usage": 495616,
+        "container_data": {
+          "pgfault": 2279
+        },
+        "hierarchical_data": {
+          "pgfault": 2279
+        }
+      }
+    },
+    {
+      "timestamp": "2014-06-13T01:03:39.662978029Z",
+      "cpu": {
+        "usage": {
+          "total": 56896502,
+          "per_cpu": [
+            20479682,
+            13579420,
+            6025040,
+            2255123,
+            3635661,
+            2489368,
+            5158288,
+            3273920
+          ],
+          "user": 10000000,
+          "system": 30000000
+        },
+        "load": 0
+      },
+      "memory": {
+        "usage": 495616,
+        "container_data": {
+          "pgfault": 2279
+        },
+        "hierarchical_data": {
+          "pgfault": 2279
+        }
+      }
+    },
+    {
+      "timestamp": "2014-06-13T01:03:40.764671232Z",
+      "cpu": {
+        "usage": {
+          "total": 56896502,
+          "per_cpu": [
+            20479682,
+            13579420,
+            6025040,
+            2255123,
+            3635661,
+            2489368,
+            5158288,
+            3273920
+          ],
+          "user": 10000000,
+          "system": 30000000
+        },
+        "load": 0
+      },
+      "memory": {
+        "usage": 495616,
+        "container_data": {
+          "pgfault": 2279
+        },
+        "hierarchical_data": {
+          "pgfault": 2279
+        }
+      }
+    },
+    {
+      "timestamp": "2014-06-13T01:03:41.866456459Z",
+      "cpu": {
+        "usage": {
+          "total": 56896502,
+          "per_cpu": [
+            20479682,
+            13579420,
+            6025040,
+            2255123,
+            3635661,
+            2489368,
+            5158288,
+            3273920
+          ],
+          "user": 10000000,
+          "system": 30000000
+        },
+        "load": 0
+      },
+      "memory": {
+        "usage": 495616,
+        "container_data": {
+          "pgfault": 2279
+        },
+        "hierarchical_data": {
+          "pgfault": 2279
+        }
+      }
+    }
+  ],
+  "stats_summary": {
+    "max_memory_usage": 495616,
+    "samples": [
+      {
+        "timestamp": "2014-06-13T01:03:27.538394608Z",
+        "duration": 1103412783,
+        "cpu": {
+          "usage": 0
+        },
+        "memory": {
+          "usage": 495616
+        }
+      },
+      {
+        "timestamp": "2014-06-13T01:03:28.640302072Z",
+        "duration": 1101907464,
+        "cpu": {
+          "usage": 0
+        },
+        "memory": {
+          "usage": 495616
+        }
+      },
+      {
+        "timestamp": "2014-06-13T01:03:29.74247308Z",
+        "duration": 1102171008,
+        "cpu": {
+          "usage": 0
+        },
+        "memory": {
+          "usage": 495616
+        }
+      },
+      {
+        "timestamp": "2014-06-13T01:03:30.844494537Z",
+        "duration": 1102021457,
+        "cpu": {
+          "usage": 0
+        },
+        "memory": {
+          "usage": 495616
+        }
+      },
+      {
+        "timestamp": "2014-06-13T01:03:31.946757066Z",
+        "duration": 1102262529,
+        "cpu": {
+          "usage": 0
+        },
+        "memory": {
+          "usage": 495616
+        }
+      },
+      {
+        "timestamp": "2014-06-13T01:03:33.050214062Z",
+        "duration": 1103456996,
+        "cpu": {
+          "usage": 0
+        },
+        "memory": {
+          "usage": 495616
+        }
+      },
+      {
+        "timestamp": "2014-06-13T01:03:34.15222186Z",
+        "duration": 1102007798,
+        "cpu": {
+          "usage": 0
+        },
+        "memory": {
+          "usage": 495616
+        }
+      },
+      {
+        "timestamp": "2014-06-13T01:03:35.25417391Z",
+        "duration": 1101952050,
+        "cpu": {
+          "usage": 0
+        },
+        "memory": {
+          "usage": 495616
+        }
+      },
+      {
+        "timestamp": "2014-06-13T01:03:36.355902169Z",
+        "duration": 1101728259,
+        "cpu": {
+          "usage": 0
+        },
+        "memory": {
+          "usage": 495616
+        }
+      },
+      {
+        "timestamp": "2014-06-13T01:03:37.457585928Z",
+        "duration": 1101683759,
+        "cpu": {
+          "usage": 0
+        },
+        "memory": {
+          "usage": 495616
+        }
+      },
+      {
+        "timestamp": "2014-06-13T01:03:38.559417379Z",
+        "duration": 1101831451,
+        "cpu": {
+          "usage": 0
+        },
+        "memory": {
+          "usage": 495616
+        }
+      },
+      {
+        "timestamp": "2014-06-13T01:03:39.662978029Z",
+        "duration": 1103560650,
+        "cpu": {
+          "usage": 0
+        },
+        "memory": {
+          "usage": 495616
+        }
+      },
+      {
+        "timestamp": "2014-06-13T01:03:40.764671232Z",
+        "duration": 1101693203,
+        "cpu": {
+          "usage": 0
+        },
+        "memory": {
+          "usage": 495616
+        }
+      },
+      {
+        "timestamp": "2014-06-13T01:03:41.866456459Z",
+        "duration": 1101785227,
+        "cpu": {
+          "usage": 0
+        },
+        "memory": {
+          "usage": 495616
+        }
+      }
+    ],
+    "memory_usage_percentiles": [
+      {
+        "percentage": 50,
+        "value": 495616
+      },
+      {
+        "percentage": 80,
+        "value": 495616
+      },
+      {
+        "percentage": 90,
+        "value": 495616
+      },
+      {
+        "percentage": 95,
+        "value": 495616
+      },
+      {
+        "percentage": 99,
+        "value": 495616
+      }
+    ],
+    "cpu_usage_percentiles": [
+      {
+        "percentage": 50,
+        "value": 0
+      },
+      {
+        "percentage": 80,
+        "value": 0
+      },
+      {
+        "percentage": 90,
+        "value": 0
+      },
+      {
+        "percentage": 95,
+        "value": 0
+      },
+      {
+        "percentage": 99,
+        "value": 0
+      }
+    ]
+  }
+}
+`
+	containerName := "/some/container"
+	respStr = fmt.Sprintf(respStr, containerName)
+	client, server, err := cadvisorTestClient(fmt.Sprintf("/api/v1.0/containers%v", containerName), respStr)
+	if err != nil {
+		t.Fatalf("unable to get a client %v", err)
+	}
+	defer server.Close()
+	err = testGetJsonData(respStr, &info.ContainerInfo{}, func() (interface{}, error) {
+		return client.ContainerInfo(containerName)
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+}

third_party/src/github.com/google/cadvisor/container/container.go

@@ -0,0 +1,35 @@
+// 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
+
+import "github.com/google/cadvisor/info"
+
+// Listing types.
+const (
+	LIST_SELF = iota
+	LIST_RECURSIVE
+)
+
+type ListType int
+
+// Interface for container operation handlers.
+type ContainerHandler interface {
+	ContainerReference() (info.ContainerReference, error)
+	GetSpec() (*info.ContainerSpec, error)
+	GetStats() (*info.ContainerStats, error)
+	ListContainers(listType ListType) ([]info.ContainerReference, error)
+	ListThreads(listType ListType) ([]int, error)
+	ListProcesses(listType ListType) ([]int, error)
+}

third_party/src/github.com/google/cadvisor/container/docker/factory.go

@@ -0,0 +1,103 @@
+// 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 docker
+
+import (
+	"flag"
+	"fmt"
+	"regexp"
+	"strconv"
+
+	"github.com/fsouza/go-dockerclient"
+	"github.com/google/cadvisor/container"
+	"github.com/google/cadvisor/info"
+)
+
+var ArgDockerEndpoint = flag.String("docker", "unix:///var/run/docker.sock", "docker endpoint")
+
+type dockerFactory struct {
+	machineInfoFactory info.MachineInfoFactory
+}
+
+func (self *dockerFactory) String() string {
+	return "docker"
+}
+
+func (self *dockerFactory) NewContainerHandler(name string) (handler container.ContainerHandler, err error) {
+	client, err := docker.NewClient(*ArgDockerEndpoint)
+	if err != nil {
+		return
+	}
+	handler, err = newDockerContainerHandler(
+		client,
+		name,
+		self.machineInfoFactory,
+	)
+	return
+}
+
+func parseDockerVersion(full_version_string string) ([]int, error) {
+	version_regexp_string := "(\\d+)\\.(\\d+)\\.(\\d+)"
+	version_re := regexp.MustCompile(version_regexp_string)
+	matches := version_re.FindAllStringSubmatch(full_version_string, -1)
+	if len(matches) != 1 {
+		return nil, fmt.Errorf("Version string \"%v\" doesn't match expected regular expression: \"%v\"", full_version_string, version_regexp_string)
+	}
+	version_string_array := matches[0][1:]
+	version_array := make([]int, 3)
+	for index, version_string := range version_string_array {
+		version, err := strconv.Atoi(version_string)
+		if err != nil {
+			return nil, fmt.Errorf("Error while parsing \"%v\" in \"%v\"", version_string, full_version_string)
+		}
+		version_array[index] = version
+	}
+	return version_array, nil
+}
+
+// Register root container before running this function!
+func Register(factory info.MachineInfoFactory, paths ...string) error {
+	client, err := docker.NewClient(*ArgDockerEndpoint)
+	if err != nil {
+		return fmt.Errorf("unable to communicate with docker daemon: %v", err)
+	}
+	if version, err := client.Version(); err != nil {
+		return fmt.Errorf("unable to communicate with docker daemon: %v", err)
+	} else {
+		expected_version := []int{0, 11, 1}
+		version_string := version.Get("Version")
+		version, err := parseDockerVersion(version_string)
+		if err != nil {
+			return fmt.Errorf("Couldn't parse docker version: %v", err)
+		}
+		for index, number := range version {
+			if number > expected_version[index] {
+				break
+			} else if number < expected_version[index] {
+				return fmt.Errorf("cAdvisor requires docker version above %v but we have found version %v reported as \"%v\"", expected_version, version, version_string)
+			}
+		}
+	}
+	f := &dockerFactory{
+		machineInfoFactory: factory,
+	}
+	for _, p := range paths {
+		if p != "/" && p != "/docker" {
+			return fmt.Errorf("%v cannot be managed by docker", p)
+		}
+		container.RegisterContainerHandlerFactory(p, f)
+	}
+	return nil
+}

third_party/src/github.com/google/cadvisor/container/docker/handler.go

@@ -0,0 +1,281 @@
+// 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 docker
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"math"
+	"os"
+	"path"
+	"strings"
+	"time"
+
+	"github.com/docker/libcontainer"
+	"github.com/docker/libcontainer/cgroups"
+	"github.com/docker/libcontainer/cgroups/fs"
+	"github.com/fsouza/go-dockerclient"
+	"github.com/google/cadvisor/container"
+	"github.com/google/cadvisor/info"
+)
+
+type dockerContainerHandler struct {
+	client             *docker.Client
+	name               string
+	aliases            []string
+	machineInfoFactory info.MachineInfoFactory
+}
+
+func newDockerContainerHandler(
+	client *docker.Client,
+	name string,
+	machineInfoFactory info.MachineInfoFactory,
+) (container.ContainerHandler, error) {
+	handler := &dockerContainerHandler{
+		client:             client,
+		name:               name,
+		machineInfoFactory: machineInfoFactory,
+	}
+	if !handler.isDockerContainer() {
+		return handler, nil
+	}
+	_, id, err := handler.splitName()
+	if err != nil {
+		return nil, fmt.Errorf("invalid docker container %v: %v", name, err)
+	}
+	ctnr, err := client.InspectContainer(id)
+	if err != nil {
+		return nil, fmt.Errorf("unable to inspect container %v: %v", name, err)
+	}
+	handler.aliases = append(handler.aliases, path.Join("/docker", ctnr.Name))
+	return handler, nil
+}
+
+func (self *dockerContainerHandler) ContainerReference() (info.ContainerReference, error) {
+	return info.ContainerReference{
+		Name:    self.name,
+		Aliases: self.aliases,
+	}, nil
+}
+
+func (self *dockerContainerHandler) splitName() (string, string, error) {
+	parent, id := path.Split(self.name)
+	cgroupSelf, err := os.Open("/proc/self/cgroup")
+	if err != nil {
+		return "", "", err
+	}
+	scanner := bufio.NewScanner(cgroupSelf)
+
+	subsys := []string{"memory", "cpu"}
+	nestedLevels := 0
+	for scanner.Scan() {
+		line := scanner.Text()
+		elems := strings.Split(line, ":")
+		if len(elems) < 3 {
+			continue
+		}
+		for _, s := range subsys {
+			if elems[1] == s {
+				// count how many nested docker containers are there.
+				nestedLevels = strings.Count(elems[2], "/docker")
+				break
+			}
+		}
+	}
+	if nestedLevels > 0 {
+		// we are running inside a docker container
+		upperLevel := strings.Repeat("../../", nestedLevels)
+		//parent = strings.Join([]string{parent, upperLevel}, "/")
+		parent = fmt.Sprintf("%v%v", upperLevel, parent)
+	}
+	return parent, id, nil
+}
+
+func (self *dockerContainerHandler) isDockerRoot() bool {
+	// TODO(dengnan): Should we consider other cases?
+	return self.name == "/docker"
+}
+
+func (self *dockerContainerHandler) isRootContainer() bool {
+	return self.name == "/"
+}
+
+func (self *dockerContainerHandler) isDockerContainer() bool {
+	return (!self.isDockerRoot()) && (!self.isRootContainer())
+}
+
+// TODO(vmarmol): Switch to getting this from libcontainer once we have a solid API.
+func readLibcontainerSpec(id string) (spec *libcontainer.Container, err error) {
+	dir := "/var/lib/docker/execdriver/native"
+	configPath := path.Join(dir, id, "container.json")
+	f, err := os.Open(configPath)
+	if err != nil {
+		return
+	}
+	defer f.Close()
+	d := json.NewDecoder(f)
+	ret := new(libcontainer.Container)
+	err = d.Decode(ret)
+	if err != nil {
+		return
+	}
+	spec = ret
+	return
+}
+
+func libcontainerConfigToContainerSpec(config *libcontainer.Container, mi *info.MachineInfo) *info.ContainerSpec {
+	spec := new(info.ContainerSpec)
+	spec.Memory = new(info.MemorySpec)
+	spec.Memory.Limit = math.MaxUint64
+	spec.Memory.SwapLimit = math.MaxUint64
+	if config.Cgroups.Memory > 0 {
+		spec.Memory.Limit = uint64(config.Cgroups.Memory)
+	}
+	if config.Cgroups.MemorySwap > 0 {
+		spec.Memory.SwapLimit = uint64(config.Cgroups.MemorySwap)
+	}
+
+	// Get CPU info
+	spec.Cpu = new(info.CpuSpec)
+	spec.Cpu.Limit = 1024
+	if config.Cgroups.CpuShares != 0 {
+		spec.Cpu.Limit = uint64(config.Cgroups.CpuShares)
+	}
+	n := (mi.NumCores + 63) / 64
+	spec.Cpu.Mask.Data = make([]uint64, n)
+	for i := 0; i < n; i++ {
+		spec.Cpu.Mask.Data[i] = math.MaxUint64
+	}
+	// TODO(vmarmol): Get CPUs from config.Cgroups.CpusetCpus
+	return spec
+}
+
+func (self *dockerContainerHandler) GetSpec() (spec *info.ContainerSpec, err error) {
+	if !self.isDockerContainer() {
+		spec = new(info.ContainerSpec)
+		return
+	}
+	mi, err := self.machineInfoFactory.GetMachineInfo()
+	if err != nil {
+		return
+	}
+	_, id, err := self.splitName()
+	if err != nil {
+		return
+	}
+	libcontainerSpec, err := readLibcontainerSpec(id)
+	if err != nil {
+		return
+	}
+
+	spec = libcontainerConfigToContainerSpec(libcontainerSpec, mi)
+	return
+}
+
+func libcontainerToContainerStats(s *cgroups.Stats, mi *info.MachineInfo) *info.ContainerStats {
+	ret := new(info.ContainerStats)
+	ret.Timestamp = time.Now()
+	ret.Cpu = new(info.CpuStats)
+	ret.Cpu.Usage.User = s.CpuStats.CpuUsage.UsageInUsermode
+	ret.Cpu.Usage.System = s.CpuStats.CpuUsage.UsageInKernelmode
+	n := len(s.CpuStats.CpuUsage.PercpuUsage)
+	ret.Cpu.Usage.PerCpu = make([]uint64, n)
+
+	ret.Cpu.Usage.Total = 0
+	for i := 0; i < n; i++ {
+		ret.Cpu.Usage.PerCpu[i] = s.CpuStats.CpuUsage.PercpuUsage[i]
+		ret.Cpu.Usage.Total += s.CpuStats.CpuUsage.PercpuUsage[i]
+	}
+	ret.Memory = new(info.MemoryStats)
+	ret.Memory.Usage = s.MemoryStats.Usage
+	if v, ok := s.MemoryStats.Stats["pgfault"]; ok {
+		ret.Memory.ContainerData.Pgfault = v
+		ret.Memory.HierarchicalData.Pgfault = v
+	}
+	if v, ok := s.MemoryStats.Stats["pgmajfault"]; ok {
+		ret.Memory.ContainerData.Pgmajfault = v
+		ret.Memory.HierarchicalData.Pgmajfault = v
+	}
+	return ret
+}
+
+func (self *dockerContainerHandler) GetStats() (stats *info.ContainerStats, err error) {
+	if !self.isDockerContainer() {
+		// Return empty stats for root containers.
+		stats = new(info.ContainerStats)
+		stats.Timestamp = time.Now()
+		return
+	}
+	mi, err := self.machineInfoFactory.GetMachineInfo()
+	if err != nil {
+		return
+	}
+	parent, id, err := self.splitName()
+	if err != nil {
+		return
+	}
+	cg := &cgroups.Cgroup{
+		Parent: parent,
+		Name:   id,
+	}
+	s, err := fs.GetStats(cg)
+	if err != nil {
+		return
+	}
+	stats = libcontainerToContainerStats(s, mi)
+	return
+}
+
+func (self *dockerContainerHandler) ListContainers(listType container.ListType) ([]info.ContainerReference, error) {
+	if self.isDockerContainer() {
+		return nil, nil
+	}
+	if self.isRootContainer() && listType == container.LIST_SELF {
+		return []info.ContainerReference{info.ContainerReference{Name: "/docker"}}, nil
+	}
+	opt := docker.ListContainersOptions{
+		All: true,
+	}
+	containers, err := self.client.ListContainers(opt)
+	if err != nil {
+		return nil, err
+	}
+	ret := make([]info.ContainerReference, 0, len(containers)+1)
+	for _, c := range containers {
+		if !strings.HasPrefix(c.Status, "Up ") {
+			continue
+		}
+		path := fmt.Sprintf("/docker/%v", c.ID)
+		aliases := c.Names
+		ref := info.ContainerReference{
+			Name:    path,
+			Aliases: aliases,
+		}
+		ret = append(ret, ref)
+	}
+	if self.isRootContainer() {
+		ret = append(ret, info.ContainerReference{Name: "/docker"})
+	}
+	return ret, nil
+}
+
+func (self *dockerContainerHandler) ListThreads(listType container.ListType) ([]int, error) {
+	return nil, nil
+}
+
+func (self *dockerContainerHandler) ListProcesses(listType container.ListType) ([]int, error) {
+	return nil, nil
+}

third_party/src/github.com/google/cadvisor/container/factory.go

@@ -0,0 +1,129 @@
+// 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
+
+import (
+	"fmt"
+	"log"
+	"strings"
+	"sync"
+)
+
+type ContainerHandlerFactory interface {
+	NewContainerHandler(name string) (ContainerHandler, error)
+
+	// for testability
+	String() string
+}
+
+type factoryTreeNode struct {
+	defaultFactory ContainerHandlerFactory
+	children       map[string]*factoryTreeNode
+}
+
+func (self *factoryTreeNode) find(elems ...string) ContainerHandlerFactory {
+	node := self
+	for _, elem := range elems {
+		if len(node.children) == 0 {
+			break
+		}
+		if child, ok := node.children[elem]; ok {
+			node = child
+		} else {
+			return node.defaultFactory
+		}
+	}
+
+	return node.defaultFactory
+}
+
+func (self *factoryTreeNode) add(factory ContainerHandlerFactory, elems ...string) {
+	node := self
+	for _, elem := range elems {
+		if node.children == nil {
+			node.children = make(map[string]*factoryTreeNode, 16)
+		}
+		child, ok := self.children[elem]
+		if !ok {
+			child = &factoryTreeNode{
+				defaultFactory: node.defaultFactory,
+				children:       make(map[string]*factoryTreeNode, 16),
+			}
+			node.children[elem] = child
+		}
+		node = child
+	}
+	node.defaultFactory = factory
+}
+
+type factoryManager struct {
+	root *factoryTreeNode
+	lock sync.RWMutex
+}
+
+func dropEmptyString(elems ...string) []string {
+	ret := make([]string, 0, len(elems))
+	for _, e := range elems {
+		if len(e) > 0 {
+			ret = append(ret, e)
+		}
+	}
+	return ret
+}
+
+// Must register factory for root container!
+func (self *factoryManager) Register(path string, factory ContainerHandlerFactory) {
+	self.lock.Lock()
+	defer self.lock.Unlock()
+
+	if self.root == nil {
+		self.root = &factoryTreeNode{
+			defaultFactory: nil,
+			children:       make(map[string]*factoryTreeNode, 10),
+		}
+	}
+
+	elems := dropEmptyString(strings.Split(path, "/")...)
+	self.root.add(factory, elems...)
+}
+
+func (self *factoryManager) NewContainerHandler(path string) (ContainerHandler, error) {
+	self.lock.RLock()
+	defer self.lock.RUnlock()
+
+	if self.root == nil {
+		err := fmt.Errorf("nil factory for container %v: no factory registered", path)
+		return nil, err
+	}
+
+	elems := dropEmptyString(strings.Split(path, "/")...)
+	factory := self.root.find(elems...)
+	if factory == nil {
+		err := fmt.Errorf("nil factory for container %v", path)
+		return nil, err
+	}
+	log.Printf("Container handler factory for %v is %v\n", path, factory)
+	return factory.NewContainerHandler(path)
+}
+
+var globalFactoryManager factoryManager
+
+func RegisterContainerHandlerFactory(path string, factory ContainerHandlerFactory) {
+	globalFactoryManager.Register(path, factory)
+}
+
+func NewContainerHandler(path string) (ContainerHandler, error) {
+	return globalFactoryManager.NewContainerHandler(path)
+}

third_party/src/github.com/google/cadvisor/container/factory_test.go

@@ -0,0 +1,76 @@
+// 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
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/mock"
+)
+
+type mockContainerHandlerFactory struct {
+	mock.Mock
+	Name string
+}
+
+func (self *mockContainerHandlerFactory) String() string {
+	return self.Name
+}
+
+func (self *mockContainerHandlerFactory) NewContainerHandler(name string) (ContainerHandler, error) {
+	args := self.Called(name)
+	return args.Get(0).(ContainerHandler), args.Error(1)
+}
+
+func testExpectedFactory(root *factoryTreeNode, path, expectedFactory string, t *testing.T) {
+	elems := dropEmptyString(strings.Split(path, "/")...)
+	factory := root.find(elems...)
+	if factory.String() != expectedFactory {
+		t.Errorf("factory %v should be used to create container %v. but %v is selected",
+			expectedFactory,
+			path,
+			factory)
+	}
+}
+
+func testAddFactory(root *factoryTreeNode, path string) *factoryTreeNode {
+	elems := dropEmptyString(strings.Split(path, "/")...)
+	if root == nil {
+		root = &factoryTreeNode{
+			defaultFactory: nil,
+		}
+	}
+	f := &mockContainerHandlerFactory{
+		Name: path,
+	}
+	root.add(f, elems...)
+	return root
+}
+
+func TestFactoryTree(t *testing.T) {
+	root := testAddFactory(nil, "/")
+	root = testAddFactory(root, "/docker")
+	root = testAddFactory(root, "/user")
+	root = testAddFactory(root, "/user/special/containers")
+
+	testExpectedFactory(root, "/docker/container", "/docker", t)
+	testExpectedFactory(root, "/docker", "/docker", t)
+	testExpectedFactory(root, "/", "/", t)
+	testExpectedFactory(root, "/user/deep/level/container", "/user", t)
+	testExpectedFactory(root, "/user/special/containers", "/user/special/containers", t)
+	testExpectedFactory(root, "/user/special/containers/container", "/user/special/containers", t)
+	testExpectedFactory(root, "/other", "/", t)
+}

third_party/src/github.com/google/cadvisor/container/filter.go

@@ -0,0 +1,93 @@
+// 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
+
+import (
+	"strings"
+
+	"github.com/google/cadvisor/info"
+)
+
+type containerListFilter struct {
+	filter  func(string) bool
+	handler ContainerHandler
+}
+
+func (self *containerListFilter) ContainerReference() (info.ContainerReference, error) {
+	return self.handler.ContainerReference()
+}
+
+func (self *containerListFilter) GetSpec() (*info.ContainerSpec, error) {
+	return self.handler.GetSpec()
+}
+
+func (self *containerListFilter) GetStats() (*info.ContainerStats, error) {
+	return self.handler.GetStats()
+}
+
+func (self *containerListFilter) ListContainers(listType ListType) ([]info.ContainerReference, error) {
+	containers, err := self.handler.ListContainers(listType)
+	if err != nil {
+		return nil, err
+	}
+	if len(containers) == 0 {
+		return nil, nil
+	}
+	ret := make([]info.ContainerReference, 0, len(containers))
+	for _, c := range containers {
+		if self.filter(c.Name) {
+			ret = append(ret, c)
+		}
+	}
+	return ret, nil
+}
+
+func (self *containerListFilter) ListThreads(listType ListType) ([]int, error) {
+	return self.handler.ListThreads(listType)
+}
+
+func (self *containerListFilter) ListProcesses(listType ListType) ([]int, error) {
+	return self.handler.ListProcesses(listType)
+}
+
+func NewWhiteListFilter(handler ContainerHandler, acceptedPaths ...string) ContainerHandler {
+	filter := func(p string) bool {
+		for _, path := range acceptedPaths {
+			if strings.HasPrefix(p, path) {
+				return true
+			}
+		}
+		return false
+	}
+	return &containerListFilter{
+		filter:  filter,
+		handler: handler,
+	}
+}
+
+func NewBlackListFilter(handler ContainerHandler, forbiddenPaths ...string) ContainerHandler {
+	filter := func(p string) bool {
+		for _, path := range forbiddenPaths {
+			if strings.HasPrefix(p, path) {
+				return false
+			}
+		}
+		return true
+	}
+	return &containerListFilter{
+		filter:  filter,
+		handler: handler,
+	}
+}

third_party/src/github.com/google/cadvisor/container/filter_test.go

@@ -0,0 +1,127 @@
+// 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
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/google/cadvisor/info"
+	"github.com/stretchr/testify/mock"
+)
+
+type mockContainerHandler struct {
+	mock.Mock
+}
+
+func (self *mockContainerHandler) GetSpec() (*info.ContainerSpec, error) {
+	args := self.Called()
+	return args.Get(0).(*info.ContainerSpec), args.Error(1)
+}
+
+func (self *mockContainerHandler) ContainerReference() (info.ContainerReference, error) {
+	args := self.Called()
+	return args.Get(0).(info.ContainerReference), args.Error(1)
+}
+
+func (self *mockContainerHandler) GetStats() (*info.ContainerStats, error) {
+	args := self.Called()
+	return args.Get(0).(*info.ContainerStats), args.Error(1)
+}
+
+func (self *mockContainerHandler) ListContainers(listType ListType) ([]info.ContainerReference, error) {
+	args := self.Called(listType)
+	return args.Get(0).([]info.ContainerReference), args.Error(1)
+}
+
+func (self *mockContainerHandler) ListThreads(listType ListType) ([]int, error) {
+	args := self.Called(listType)
+	return args.Get(0).([]int), args.Error(1)
+}
+
+func (self *mockContainerHandler) ListProcesses(listType ListType) ([]int, error) {
+	args := self.Called(listType)
+	return args.Get(0).([]int), args.Error(1)
+}
+
+func TestWhiteListContainerFilter(t *testing.T) {
+	mockc := &mockContainerHandler{}
+	mockc.On("ListContainers", LIST_RECURSIVE).Return(
+		[]info.ContainerReference{
+			info.ContainerReference{Name: "/docker/ee0103"},
+			info.ContainerReference{Name: "/container/created/by/lmctfy"},
+			info.ContainerReference{Name: "/user/something"},
+		},
+		nil,
+	)
+
+	filterPaths := []string{
+		"/docker",
+		"/container",
+	}
+
+	fc := NewWhiteListFilter(mockc, filterPaths...)
+	containers, err := fc.ListContainers(LIST_RECURSIVE)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, c := range containers {
+		legal := false
+		for _, prefix := range filterPaths {
+			if strings.HasPrefix(c.Name, prefix) {
+				legal = true
+			}
+		}
+		if !legal {
+			t.Errorf("%v is not in the white list", c)
+		}
+	}
+	mockc.AssertExpectations(t)
+}
+
+func TestBlackListContainerFilter(t *testing.T) {
+	mockc := &mockContainerHandler{}
+	mockc.On("ListContainers", LIST_RECURSIVE).Return(
+		[]info.ContainerReference{
+			info.ContainerReference{Name: "/docker/ee0103"},
+			info.ContainerReference{Name: "/container/created/by/lmctfy"},
+			info.ContainerReference{Name: "/user/something"},
+		},
+		nil,
+	)
+
+	filterPaths := []string{
+		"/docker",
+		"/container",
+	}
+
+	fc := NewBlackListFilter(mockc, filterPaths...)
+	containers, err := fc.ListContainers(LIST_RECURSIVE)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, c := range containers {
+		legal := true
+		for _, prefix := range filterPaths {
+			if strings.HasPrefix(c.Name, prefix) {
+				legal = false
+			}
+		}
+		if !legal {
+			t.Errorf("%v is in the black list", c)
+		}
+	}
+	mockc.AssertExpectations(t)
+}

third_party/src/github.com/google/cadvisor/container/lmctfy/factory.go

@@ -0,0 +1,52 @@
+// 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 lmctfy
+
+import (
+	"errors"
+	"log"
+	"os/exec"
+
+	"github.com/google/cadvisor/container"
+)
+
+func Register(paths ...string) error {
+	if _, err := exec.LookPath("lmctfy"); err != nil {
+		return errors.New("cannot find lmctfy")
+	}
+	f := &lmctfyFactory{}
+	for _, path := range paths {
+		log.Printf("register lmctfy under %v", path)
+		container.RegisterContainerHandlerFactory(path, f)
+	}
+	return nil
+}
+
+type lmctfyFactory struct {
+}
+
+func (self *lmctfyFactory) String() string {
+	return "lmctfy"
+}
+
+func (self *lmctfyFactory) NewContainerHandler(name string) (container.ContainerHandler, error) {
+	c, err := New(name)
+	if err != nil {
+		return nil, err
+	}
+	// XXX(dengnan): /user is created by ubuntu 14.04. Not sure if we should list it
+	handler := container.NewBlackListFilter(c, "/user")
+	return handler, nil
+}

third_party/src/github.com/google/cadvisor/container/lmctfy/lmctfy_container.go

@@ -0,0 +1,199 @@
+// 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.
+
+// A container object
+
+package lmctfy
+
+import (
+	"fmt"
+	"os/exec"
+	"strings"
+	"syscall"
+	"time"
+
+	"code.google.com/p/goprotobuf/proto"
+	"github.com/google/cadvisor/container"
+	"github.com/google/cadvisor/info"
+)
+
+type lmctfyContainerHandler struct {
+	// Container name
+	Name string
+}
+
+const (
+	lmctfyBinary     = "lmctfy"
+	notFoundExitCode = 5
+)
+
+// Create a new
+func New(name string) (container.ContainerHandler, error) {
+	el := &lmctfyContainerHandler{
+		Name: name,
+	}
+	return el, nil
+}
+
+func (self *lmctfyContainerHandler) ContainerReference() (info.ContainerReference, error) {
+	return info.ContainerReference{Name: self.Name}, nil
+}
+
+func getExitCode(err error) int {
+	msg, ok := err.(*exec.ExitError)
+	if ok {
+		return msg.Sys().(syscall.WaitStatus).ExitStatus()
+	}
+	return -1
+}
+
+func protobufToContainerSpec(pspec *ContainerSpec) *info.ContainerSpec {
+	ret := new(info.ContainerSpec)
+	if pspec.GetCpu() != nil {
+		cpuspec := new(info.CpuSpec)
+		cpuspec.Limit = pspec.GetCpu().GetLimit()
+		cpuspec.MaxLimit = pspec.GetCpu().GetMaxLimit()
+		if pspec.GetCpu().GetMask() != nil {
+			cpuspec.Mask.Data = pspec.GetCpu().GetMask().GetData()
+		}
+		ret.Cpu = cpuspec
+	}
+	if pspec.GetMemory() != nil {
+		pmem := pspec.GetMemory()
+		memspec := new(info.MemorySpec)
+		memspec.Limit = uint64(pmem.GetLimit())
+		memspec.Reservation = uint64(pmem.GetReservation())
+		memspec.SwapLimit = uint64(pmem.GetSwapLimit())
+		ret.Memory = memspec
+	}
+	return ret
+}
+
+// Gets spec.
+func (c *lmctfyContainerHandler) GetSpec() (*info.ContainerSpec, error) {
+	// Run lmctfy spec "container_name" and get spec.
+	// Ignore if the container was not found.
+	cmd := exec.Command(lmctfyBinary, "spec", string(c.Name))
+	data, err := cmd.Output()
+	if err != nil && getExitCode(err) != notFoundExitCode {
+		return nil, fmt.Errorf("unable to run command %v spec %v: %v", lmctfyBinary, c.Name, err)
+	}
+
+	// Parse output into a protobuf.
+	pspec := &ContainerSpec{}
+	err = proto.UnmarshalText(string(data), pspec)
+	if err != nil {
+		return nil, err
+	}
+	spec := protobufToContainerSpec(pspec)
+	return spec, nil
+}
+
+func protobufToMemoryData(pmd *MemoryStats_MemoryData, data *info.MemoryStatsMemoryData) {
+	if pmd == nil {
+		return
+	}
+	data.Pgfault = uint64(pmd.GetPgfault())
+	data.Pgmajfault = uint64(pmd.GetPgmajfault())
+	return
+}
+
+func protobufToContainerStats(pstats *ContainerStats) *info.ContainerStats {
+	ret := new(info.ContainerStats)
+	if pstats.GetCpu() != nil {
+		pcpu := pstats.GetCpu()
+		cpustats := new(info.CpuStats)
+		cpustats.Usage.Total = pcpu.GetUsage().GetTotal()
+		percpu := pcpu.GetUsage().GetPerCpu()
+		if len(percpu) > 0 {
+			cpustats.Usage.PerCpu = make([]uint64, len(percpu))
+			for i, p := range percpu {
+				cpustats.Usage.PerCpu[i] = uint64(p)
+			}
+		}
+		cpustats.Usage.User = uint64(pcpu.GetUsage().GetUser())
+		cpustats.Usage.System = uint64(pcpu.GetUsage().GetSystem())
+		cpustats.Load = pcpu.GetLoad()
+		ret.Cpu = cpustats
+	}
+	if pstats.GetMemory() != nil {
+		pmem := pstats.GetMemory()
+		memstats := new(info.MemoryStats)
+		memstats.Limit = uint64(pmem.GetLimit())
+		memstats.Usage = uint64(pmem.GetUsage())
+		protobufToMemoryData(pmem.GetContainerData(), &memstats.ContainerData)
+		protobufToMemoryData(pmem.GetHierarchicalData(), &memstats.HierarchicalData)
+		ret.Memory = memstats
+	}
+	return ret
+}
+
+// Gets full stats.
+func (c *lmctfyContainerHandler) GetStats() (*info.ContainerStats, error) {
+	// Ignore if the container was not found.
+	cmd := exec.Command(lmctfyBinary, "stats", "full", string(c.Name))
+	data, err := cmd.Output()
+	if err != nil && getExitCode(err) != notFoundExitCode {
+		return nil, fmt.Errorf("unable to run command %v stats full %v: %v", lmctfyBinary, c.Name, err)
+	}
+
+	// Parse output into a protobuf.
+	pstats := &ContainerStats{}
+	err = proto.UnmarshalText(string(data), pstats)
+	if err != nil {
+		return nil, err
+	}
+	stats := protobufToContainerStats(pstats)
+	stats.Timestamp = time.Now()
+	return stats, nil
+}
+
+// Gets all subcontainers.
+func (c *lmctfyContainerHandler) ListContainers(listType container.ListType) ([]info.ContainerReference, error) {
+	// Prepare the arguments.
+	args := []string{"list", "containers", "-v"}
+	if listType == container.LIST_RECURSIVE {
+		args = append(args, "-r")
+	}
+	args = append(args, c.Name)
+
+	// Run the command.
+	cmd := exec.Command(lmctfyBinary, args...)
+	data, err := cmd.Output()
+	if err != nil && getExitCode(err) != notFoundExitCode {
+		return nil, err
+	}
+
+	// Parse lines as container names.
+	if len(data) == 0 {
+		return nil, nil
+	}
+	names := strings.Split(string(data), "\n")
+	containerNames := make([]info.ContainerReference, 0, len(names))
+	for _, name := range names {
+		if len(name) != 0 {
+			ref := info.ContainerReference{Name: name}
+			containerNames = append(containerNames, ref)
+		}
+	}
+	return containerNames, nil
+}
+
+// TODO(vmarmol): Implement
+func (c *lmctfyContainerHandler) ListThreads(listType container.ListType) ([]int, error) {
+	return []int{}, nil
+}
+func (c *lmctfyContainerHandler) ListProcesses(listType container.ListType) ([]int, error) {
+	return []int{}, nil
+}

third_party/src/github.com/google/cadvisor/container/lmctfy/virtual_host.pb.go

@@ -0,0 +1,273 @@
+// 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.
+
+// Code generated by protoc-gen-go.
+// source: virtual_host.proto
+// DO NOT EDIT!
+
+package lmctfy
+
+import proto "code.google.com/p/goprotobuf/proto"
+import json "encoding/json"
+import math "math"
+
+// Reference proto, json, and math imports to suppress error if they are not otherwise used.
+var _ = proto.Marshal
+var _ = &json.SyntaxError{}
+var _ = math.Inf
+
+type Network_Bridge_Type int32
+
+const (
+	Network_Bridge_ETH Network_Bridge_Type = 0
+	Network_Bridge_OVS Network_Bridge_Type = 1
+)
+
+var Network_Bridge_Type_name = map[int32]string{
+	0: "ETH",
+	1: "OVS",
+}
+var Network_Bridge_Type_value = map[string]int32{
+	"ETH": 0,
+	"OVS": 1,
+}
+
+func (x Network_Bridge_Type) Enum() *Network_Bridge_Type {
+	p := new(Network_Bridge_Type)
+	*p = x
+	return p
+}
+func (x Network_Bridge_Type) String() string {
+	return proto.EnumName(Network_Bridge_Type_name, int32(x))
+}
+func (x *Network_Bridge_Type) UnmarshalJSON(data []byte) error {
+	value, err := proto.UnmarshalJSONEnum(Network_Bridge_Type_value, data, "Network_Bridge_Type")
+	if err != nil {
+		return err
+	}
+	*x = Network_Bridge_Type(value)
+	return nil
+}
+
+type Network struct {
+	Interface        *string             `protobuf:"bytes,1,opt,name=interface" json:"interface,omitempty"`
+	Connection       *Network_Connection `protobuf:"bytes,3,opt,name=connection" json:"connection,omitempty"`
+	VirtualIp        *Network_VirtualIp  `protobuf:"bytes,2,opt,name=virtual_ip" json:"virtual_ip,omitempty"`
+	XXX_unrecognized []byte              `json:"-"`
+}
+
+func (m *Network) Reset()         { *m = Network{} }
+func (m *Network) String() string { return proto.CompactTextString(m) }
+func (*Network) ProtoMessage()    {}
+
+func (m *Network) GetInterface() string {
+	if m != nil && m.Interface != nil {
+		return *m.Interface
+	}
+	return ""
+}
+
+func (m *Network) GetConnection() *Network_Connection {
+	if m != nil {
+		return m.Connection
+	}
+	return nil
+}
+
+func (m *Network) GetVirtualIp() *Network_VirtualIp {
+	if m != nil {
+		return m.VirtualIp
+	}
+	return nil
+}
+
+type Network_VethPair struct {
+	Outside          *string `protobuf:"bytes,1,opt,name=outside" json:"outside,omitempty"`
+	Inside           *string `protobuf:"bytes,2,opt,name=inside" json:"inside,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *Network_VethPair) Reset()         { *m = Network_VethPair{} }
+func (m *Network_VethPair) String() string { return proto.CompactTextString(m) }
+func (*Network_VethPair) ProtoMessage()    {}
+
+func (m *Network_VethPair) GetOutside() string {
+	if m != nil && m.Outside != nil {
+		return *m.Outside
+	}
+	return ""
+}
+
+func (m *Network_VethPair) GetInside() string {
+	if m != nil && m.Inside != nil {
+		return *m.Inside
+	}
+	return ""
+}
+
+type Network_Bridge struct {
+	Name             *string              `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+	Type             *Network_Bridge_Type `protobuf:"varint,2,opt,name=type,enum=containers.Network_Bridge_Type" json:"type,omitempty"`
+	XXX_unrecognized []byte               `json:"-"`
+}
+
+func (m *Network_Bridge) Reset()         { *m = Network_Bridge{} }
+func (m *Network_Bridge) String() string { return proto.CompactTextString(m) }
+func (*Network_Bridge) ProtoMessage()    {}
+
+func (m *Network_Bridge) GetName() string {
+	if m != nil && m.Name != nil {
+		return *m.Name
+	}
+	return ""
+}
+
+func (m *Network_Bridge) GetType() Network_Bridge_Type {
+	if m != nil && m.Type != nil {
+		return *m.Type
+	}
+	return Network_Bridge_ETH
+}
+
+type Network_Connection struct {
+	VethPair         *Network_VethPair `protobuf:"bytes,1,opt,name=veth_pair" json:"veth_pair,omitempty"`
+	Bridge           *Network_Bridge   `protobuf:"bytes,2,opt,name=bridge" json:"bridge,omitempty"`
+	XXX_unrecognized []byte            `json:"-"`
+}
+
+func (m *Network_Connection) Reset()         { *m = Network_Connection{} }
+func (m *Network_Connection) String() string { return proto.CompactTextString(m) }
+func (*Network_Connection) ProtoMessage()    {}
+
+func (m *Network_Connection) GetVethPair() *Network_VethPair {
+	if m != nil {
+		return m.VethPair
+	}
+	return nil
+}
+
+func (m *Network_Connection) GetBridge() *Network_Bridge {
+	if m != nil {
+		return m.Bridge
+	}
+	return nil
+}
+
+type Network_VirtualIp struct {
+	Ip               *string `protobuf:"bytes,1,opt,name=ip" json:"ip,omitempty"`
+	Netmask          *string `protobuf:"bytes,2,opt,name=netmask" json:"netmask,omitempty"`
+	Gateway          *string `protobuf:"bytes,3,opt,name=gateway" json:"gateway,omitempty"`
+	Mtu              *int32  `protobuf:"varint,4,opt,name=mtu" json:"mtu,omitempty"`
+	IpForward        *bool   `protobuf:"varint,5,opt,name=ip_forward" json:"ip_forward,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *Network_VirtualIp) Reset()         { *m = Network_VirtualIp{} }
+func (m *Network_VirtualIp) String() string { return proto.CompactTextString(m) }
+func (*Network_VirtualIp) ProtoMessage()    {}
+
+func (m *Network_VirtualIp) GetIp() string {
+	if m != nil && m.Ip != nil {
+		return *m.Ip
+	}
+	return ""
+}
+
+func (m *Network_VirtualIp) GetNetmask() string {
+	if m != nil && m.Netmask != nil {
+		return *m.Netmask
+	}
+	return ""
+}
+
+func (m *Network_VirtualIp) GetGateway() string {
+	if m != nil && m.Gateway != nil {
+		return *m.Gateway
+	}
+	return ""
+}
+
+func (m *Network_VirtualIp) GetMtu() int32 {
+	if m != nil && m.Mtu != nil {
+		return *m.Mtu
+	}
+	return 0
+}
+
+func (m *Network_VirtualIp) GetIpForward() bool {
+	if m != nil && m.IpForward != nil {
+		return *m.IpForward
+	}
+	return false
+}
+
+type Mounts struct {
+	Mount            []*Mounts_Mount `protobuf:"bytes,1,rep,name=mount" json:"mount,omitempty"`
+	XXX_unrecognized []byte          `json:"-"`
+}
+
+func (m *Mounts) Reset()         { *m = Mounts{} }
+func (m *Mounts) String() string { return proto.CompactTextString(m) }
+func (*Mounts) ProtoMessage()    {}
+
+func (m *Mounts) GetMount() []*Mounts_Mount {
+	if m != nil {
+		return m.Mount
+	}
+	return nil
+}
+
+type Mounts_Mount struct {
+	Source           *string `protobuf:"bytes,1,opt,name=source" json:"source,omitempty"`
+	Target           *string `protobuf:"bytes,2,opt,name=target" json:"target,omitempty"`
+	ReadOnly         *bool   `protobuf:"varint,3,opt,name=read_only" json:"read_only,omitempty"`
+	Private          *bool   `protobuf:"varint,4,opt,name=private" json:"private,omitempty"`
+	XXX_unrecognized []byte  `json:"-"`
+}
+
+func (m *Mounts_Mount) Reset()         { *m = Mounts_Mount{} }
+func (m *Mounts_Mount) String() string { return proto.CompactTextString(m) }
+func (*Mounts_Mount) ProtoMessage()    {}
+
+func (m *Mounts_Mount) GetSource() string {
+	if m != nil && m.Source != nil {
+		return *m.Source
+	}
+	return ""
+}
+
+func (m *Mounts_Mount) GetTarget() string {
+	if m != nil && m.Target != nil {
+		return *m.Target
+	}
+	return ""
+}
+
+func (m *Mounts_Mount) GetReadOnly() bool {
+	if m != nil && m.ReadOnly != nil {
+		return *m.ReadOnly
+	}
+	return false
+}
+
+func (m *Mounts_Mount) GetPrivate() bool {
+	if m != nil && m.Private != nil {
+		return *m.Private
+	}
+	return false
+}
+
+func init() {
+	proto.RegisterEnum("containers.Network_Bridge_Type", Network_Bridge_Type_name, Network_Bridge_Type_value)
+}

third_party/src/github.com/google/cadvisor/deploy/docker-only/Dockerfile

@@ -0,0 +1,9 @@
+FROM busybox:ubuntu-14.04
+MAINTAINER kyurtsever@google.com dengnan@google.com vmarmol@google.com jason@swindle.me
+
+# Get cAdvisor binaries.
+ADD http://storage.googleapis.com/cadvisor-bin/cadvisor /usr/bin/cadvisor
+RUN chmod +x /usr/bin/cadvisor
+
+EXPOSE 8080
+ENTRYPOINT ["/usr/bin/cadvisor"]

third_party/src/github.com/google/cadvisor/deploy/lmctfy-docker/Dockerfile

@@ -0,0 +1,14 @@
+FROM ubuntu:14.04
+MAINTAINER kyurtsever@google.com dengnan@google.com vmarmol@google.com
+
+# Get the lmctfy dependencies.
+RUN apt-get update && apt-get install -y -q --no-install-recommends pkg-config libprotobuf8 libapparmor1
+
+# Get the lcmtfy and cAdvisor binaries.
+ADD http://storage.googleapis.com/cadvisor-bin/lmctfy/lmctfy /usr/bin/lmctfy
+ADD http://storage.googleapis.com/cadvisor-bin/lmctfy/libre2.so.0.0.0 /usr/lib/libre2.so.0
+ADD http://storage.googleapis.com/cadvisor-bin/cadvisor /usr/bin/cadvisor
+RUN chmod +x /usr/bin/lmctfy && chmod +x /usr/bin/cadvisor
+
+EXPOSE 8080
+ENTRYPOINT ["/usr/bin/cadvisor"]

third_party/src/github.com/google/cadvisor/info/container.go

@@ -0,0 +1,280 @@
+// 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 info
+
+import (
+	"fmt"
+	"sort"
+	"time"
+)
+
+type CpuSpecMask struct {
+	Data []uint64 `json:"data,omitempty"`
+}
+
+type CpuSpec struct {
+	Limit    uint64      `json:"limit"`
+	MaxLimit uint64      `json:"max_limit"`
+	Mask     CpuSpecMask `json:"mask,omitempty"`
+}
+
+type MemorySpec struct {
+	// The amount of memory requested. Default is unlimited (-1).
+	// Units: bytes.
+	Limit uint64 `json:"limit,omitempty"`
+
+	// The amount of guaranteed memory.  Default is 0.
+	// Units: bytes.
+	Reservation uint64 `json:"reservation,omitempty"`
+
+	// The amount of swap space requested. Default is unlimited (-1).
+	// Units: bytes.
+	SwapLimit uint64 `json:"swap_limit,omitempty"`
+}
+
+type ContainerSpec struct {
+	Cpu    *CpuSpec    `json:"cpu,omitempty"`
+	Memory *MemorySpec `json:"memory,omitempty"`
+}
+
+// Container reference contains enough information to uniquely identify a container
+type ContainerReference struct {
+	// The absolute name of the container.
+	Name string `json:"name"`
+
+	Aliases []string `json:"aliases,omitempty"`
+}
+
+type ContainerInfo struct {
+	ContainerReference
+
+	// The direct subcontainers of the current container.
+	Subcontainers []ContainerReference `json:"subcontainers,omitempty"`
+
+	// The isolation used in the container.
+	Spec *ContainerSpec `json:"spec,omitempty"`
+
+	// Historical statistics gathered from the container.
+	Stats []*ContainerStats `json:"stats,omitempty"`
+
+	// Randomly sampled container states.
+	Samples []*ContainerStatsSample `json:"samples,omitempty"`
+
+	StatsPercentiles *ContainerStatsPercentiles `json:"stats_summary,omitempty"`
+}
+
+func (self *ContainerInfo) StatsAfter(ref time.Time) []*ContainerStats {
+	n := len(self.Stats) + 1
+	for i, s := range self.Stats {
+		if s.Timestamp.After(ref) {
+			n = i
+			break
+		}
+	}
+	if n > len(self.Stats) {
+		return nil
+	}
+	return self.Stats[n:]
+}
+
+func (self *ContainerInfo) StatsStartTime() time.Time {
+	var ret time.Time
+	for _, s := range self.Stats {
+		if s.Timestamp.Before(ret) || ret.IsZero() {
+			ret = s.Timestamp
+		}
+	}
+	return ret
+}
+
+func (self *ContainerInfo) StatsEndTime() time.Time {
+	var ret time.Time
+	for i := len(self.Stats) - 1; i >= 0; i-- {
+		s := self.Stats[i]
+		if s.Timestamp.After(ret) {
+			ret = s.Timestamp
+		}
+	}
+	return ret
+}
+
+// All CPU usage metrics are cumulative from the creation of the container
+type CpuStats struct {
+	Usage struct {
+		// Total CPU usage.
+		// Units: nanoseconds
+		Total uint64 `json:"total"`
+
+		// Per CPU/core usage of the container.
+		// Unit: nanoseconds.
+		PerCpu []uint64 `json:"per_cpu,omitempty"`
+
+		// Time spent in user space.
+		// Unit: nanoseconds
+		User uint64 `json:"user"`
+
+		// Time spent in kernel space.
+		// Unit: nanoseconds
+		System uint64 `json:"system"`
+	} `json:"usage"`
+	Load int32 `json:"load"`
+}
+
+type MemoryStats struct {
+	// Memory limit, equivalent to "limit" in MemorySpec.
+	// Units: Bytes.
+	Limit uint64 `json:"limit,omitempty"`
+
+	// Usage statistics.
+
+	// Current memory usage, this includes all memory regardless of when it was
+	// accessed.
+	// Units: Bytes.
+	Usage uint64 `json:"usage,omitempty"`
+
+	// The amount of working set memory, this includes recently accessed memory,
+	// dirty memory, and kernel memory. Working set is <= "usage".
+	// Units: Bytes.
+	WorkingSet uint64 `json:"working_set,omitempty"`
+
+	ContainerData    MemoryStatsMemoryData `json:"container_data,omitempty"`
+	HierarchicalData MemoryStatsMemoryData `json:"hierarchical_data,omitempty"`
+}
+
+type MemoryStatsMemoryData struct {
+	Pgfault    uint64 `json:"pgfault,omitempty"`
+	Pgmajfault uint64 `json:"pgmajfault,omitempty"`
+}
+
+type ContainerStats struct {
+	// The time of this stat point.
+	Timestamp time.Time    `json:"timestamp"`
+	Cpu       *CpuStats    `json:"cpu,omitempty"`
+	Memory    *MemoryStats `json:"memory,omitempty"`
+}
+
+type ContainerStatsSample struct {
+	// Timetamp of the end of the sample period
+	Timestamp time.Time `json:"timestamp"`
+	// Duration of the sample period
+	Duration time.Duration `json:"duration"`
+	Cpu      struct {
+		// number of nanoseconds of CPU time used by the container
+		Usage uint64 `json:"usage"`
+	} `json:"cpu"`
+	Memory struct {
+		// Units: Bytes.
+		Usage uint64 `json:"usage"`
+	} `json:"memory"`
+}
+
+type Percentile struct {
+	Percentage int    `json:"percentage"`
+	Value      uint64 `json:"value"`
+}
+
+type ContainerStatsPercentiles struct {
+	MaxMemoryUsage         uint64       `json:"max_memory_usage,omitempty"`
+	MemoryUsagePercentiles []Percentile `json:"memory_usage_percentiles,omitempty"`
+	CpuUsagePercentiles    []Percentile `json:"cpu_usage_percentiles,omitempty"`
+}
+
+// Each sample needs two stats because the cpu usage in ContainerStats is
+// cumulative.
+// prev should be an earlier observation than current.
+// This method is not thread/goroutine safe.
+func NewSample(prev, current *ContainerStats) (*ContainerStatsSample, error) {
+	if prev == nil || current == nil {
+		return nil, fmt.Errorf("empty stats")
+	}
+	// Ignore this sample if it is incomplete
+	if prev.Cpu == nil || prev.Memory == nil || current.Cpu == nil || current.Memory == nil {
+		return nil, fmt.Errorf("incomplete stats")
+	}
+	// prev must be an early observation
+	if !current.Timestamp.After(prev.Timestamp) {
+		return nil, fmt.Errorf("wrong stats order")
+	}
+	// This data is invalid.
+	if current.Cpu.Usage.Total < prev.Cpu.Usage.Total {
+		return nil, fmt.Errorf("current CPU usage is less than prev CPU usage (cumulative).")
+	}
+	sample := new(ContainerStatsSample)
+	// Calculate the diff to get the CPU usage within the time interval.
+	sample.Cpu.Usage = current.Cpu.Usage.Total - prev.Cpu.Usage.Total
+	// Memory usage is current memory usage
+	sample.Memory.Usage = current.Memory.Usage
+	sample.Timestamp = current.Timestamp
+	sample.Duration = current.Timestamp.Sub(prev.Timestamp)
+
+	return sample, nil
+}
+
+type uint64Slice []uint64
+
+func (self uint64Slice) Len() int {
+	return len(self)
+}
+
+func (self uint64Slice) Less(i, j int) bool {
+	return self[i] < self[j]
+}
+
+func (self uint64Slice) Swap(i, j int) {
+	self[i], self[j] = self[j], self[i]
+}
+
+func (self uint64Slice) Percentiles(requestedPercentiles ...int) []Percentile {
+	if len(self) == 0 {
+		return nil
+	}
+	ret := make([]Percentile, 0, len(requestedPercentiles))
+	sort.Sort(self)
+	for _, p := range requestedPercentiles {
+		idx := (len(self) * p / 100) - 1
+		if idx < 0 {
+			idx = 0
+		}
+		ret = append(
+			ret,
+			Percentile{
+				Percentage: p,
+				Value:      self[idx],
+			},
+		)
+	}
+	return ret
+}
+
+func NewPercentiles(samples []*ContainerStatsSample, cpuPercentages, memoryPercentages []int) *ContainerStatsPercentiles {
+	if len(samples) == 0 {
+		return nil
+	}
+	cpuUsages := make([]uint64, 0, len(samples))
+	memUsages := make([]uint64, 0, len(samples))
+
+	for _, sample := range samples {
+		if sample == nil {
+			continue
+		}
+		cpuUsages = append(cpuUsages, sample.Cpu.Usage)
+		memUsages = append(memUsages, sample.Memory.Usage)
+	}
+
+	ret := new(ContainerStatsPercentiles)
+	ret.CpuUsagePercentiles = uint64Slice(cpuUsages).Percentiles(cpuPercentages...)
+	ret.MemoryUsagePercentiles = uint64Slice(memUsages).Percentiles(memoryPercentages...)
+	return ret
+}

third_party/src/github.com/google/cadvisor/info/container_test.go

@@ -0,0 +1,232 @@
+// 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 info
+
+import (
+	"testing"
+	"time"
+)
+
+func TestStatsStartTime(t *testing.T) {
+	N := 10
+	stats := make([]*ContainerStats, 0, N)
+	ct := time.Now()
+	for i := 0; i < N; i++ {
+		s := &ContainerStats{
+			Timestamp: ct.Add(time.Duration(i) * time.Second),
+		}
+		stats = append(stats, s)
+	}
+	cinfo := &ContainerInfo{
+		ContainerReference: ContainerReference{
+			Name: "/some/container",
+		},
+		Stats: stats,
+	}
+	ref := ct.Add(time.Duration(N-1) * time.Second)
+	end := cinfo.StatsEndTime()
+
+	if !ref.Equal(end) {
+		t.Errorf("end time is %v; should be %v", end, ref)
+	}
+}
+
+func TestStatsEndTime(t *testing.T) {
+	N := 10
+	stats := make([]*ContainerStats, 0, N)
+	ct := time.Now()
+	for i := 0; i < N; i++ {
+		s := &ContainerStats{
+			Timestamp: ct.Add(time.Duration(i) * time.Second),
+		}
+		stats = append(stats, s)
+	}
+	cinfo := &ContainerInfo{
+		ContainerReference: ContainerReference{
+			Name: "/some/container",
+		},
+		Stats: stats,
+	}
+	ref := ct
+	start := cinfo.StatsStartTime()
+
+	if !ref.Equal(start) {
+		t.Errorf("start time is %v; should be %v", start, ref)
+	}
+}
+
+func TestPercentiles(t *testing.T) {
+	N := 100
+	data := make([]uint64, N)
+
+	for i := 1; i < N+1; i++ {
+		data[i-1] = uint64(i)
+	}
+	percentages := []int{
+		80,
+		90,
+		50,
+	}
+	percentiles := uint64Slice(data).Percentiles(percentages...)
+	for _, s := range percentiles {
+		if s.Value != uint64(s.Percentage) {
+			t.Errorf("%v percentile data should be %v, but got %v", s.Percentage, s.Percentage, s.Value)
+		}
+	}
+}
+
+func TestPercentilesSmallDataSet(t *testing.T) {
+	var value uint64 = 11
+	data := []uint64{value}
+
+	percentages := []int{
+		80,
+		90,
+		50,
+	}
+	percentiles := uint64Slice(data).Percentiles(percentages...)
+	for _, s := range percentiles {
+		if s.Value != value {
+			t.Errorf("%v percentile data should be %v, but got %v", s.Percentage, value, s.Value)
+		}
+	}
+}
+
+func TestNewSampleNilStats(t *testing.T) {
+	stats := &ContainerStats{
+		Cpu:    &CpuStats{},
+		Memory: &MemoryStats{},
+	}
+	stats.Cpu.Usage.PerCpu = []uint64{uint64(10)}
+	stats.Cpu.Usage.Total = uint64(10)
+	stats.Cpu.Usage.System = uint64(2)
+	stats.Cpu.Usage.User = uint64(8)
+	stats.Memory.Usage = uint64(200)
+
+	sample, err := NewSample(nil, stats)
+	if err == nil {
+		t.Errorf("generated an unexpected sample: %+v", sample)
+	}
+
+	sample, err = NewSample(stats, nil)
+	if err == nil {
+		t.Errorf("generated an unexpected sample: %+v", sample)
+	}
+}
+
+func createStats(cpuUsage, memUsage uint64, timestamp time.Time) *ContainerStats {
+	stats := &ContainerStats{
+		Cpu:    &CpuStats{},
+		Memory: &MemoryStats{},
+	}
+	stats.Cpu.Usage.PerCpu = []uint64{cpuUsage}
+	stats.Cpu.Usage.Total = cpuUsage
+	stats.Cpu.Usage.System = 0
+	stats.Cpu.Usage.User = cpuUsage
+	stats.Memory.Usage = memUsage
+	stats.Timestamp = timestamp
+	return stats
+}
+
+func TestAddSample(t *testing.T) {
+	cpuPrevUsage := uint64(10)
+	cpuCurrentUsage := uint64(15)
+	memCurrentUsage := uint64(200)
+	prevTime := time.Now()
+
+	prev := createStats(cpuPrevUsage, memCurrentUsage, prevTime)
+	current := createStats(cpuCurrentUsage, memCurrentUsage, prevTime.Add(1*time.Second))
+
+	sample, err := NewSample(prev, current)
+	if err != nil {
+		t.Errorf("should be able to generate a sample. but received error: %v", err)
+	}
+	if sample == nil {
+		t.Fatalf("nil sample and nil error. unexpected result!")
+	}
+
+	if sample.Memory.Usage != memCurrentUsage {
+		t.Errorf("wrong memory usage: %v. should be %v", sample.Memory.Usage, memCurrentUsage)
+	}
+
+	if sample.Cpu.Usage != cpuCurrentUsage-cpuPrevUsage {
+		t.Errorf("wrong CPU usage: %v. should be %v", sample.Cpu.Usage, cpuCurrentUsage-cpuPrevUsage)
+	}
+}
+
+func TestAddSampleIncompleteStats(t *testing.T) {
+	cpuPrevUsage := uint64(10)
+	cpuCurrentUsage := uint64(15)
+	memCurrentUsage := uint64(200)
+	prevTime := time.Now()
+
+	prev := createStats(cpuPrevUsage, memCurrentUsage, prevTime)
+	current := createStats(cpuCurrentUsage, memCurrentUsage, prevTime.Add(1*time.Second))
+	stats := &ContainerStats{
+		Cpu:    prev.Cpu,
+		Memory: nil,
+	}
+	sample, err := NewSample(stats, current)
+	if err == nil {
+		t.Errorf("generated an unexpected sample: %+v", sample)
+	}
+	sample, err = NewSample(prev, stats)
+	if err == nil {
+		t.Errorf("generated an unexpected sample: %+v", sample)
+	}
+
+	stats = &ContainerStats{
+		Cpu:    nil,
+		Memory: prev.Memory,
+	}
+	sample, err = NewSample(stats, current)
+	if err == nil {
+		t.Errorf("generated an unexpected sample: %+v", sample)
+	}
+	sample, err = NewSample(prev, stats)
+	if err == nil {
+		t.Errorf("generated an unexpected sample: %+v", sample)
+	}
+}
+
+func TestAddSampleWrongOrder(t *testing.T) {
+	cpuPrevUsage := uint64(10)
+	cpuCurrentUsage := uint64(15)
+	memCurrentUsage := uint64(200)
+	prevTime := time.Now()
+
+	prev := createStats(cpuPrevUsage, memCurrentUsage, prevTime)
+	current := createStats(cpuCurrentUsage, memCurrentUsage, prevTime.Add(1*time.Second))
+
+	sample, err := NewSample(current, prev)
+	if err == nil {
+		t.Errorf("generated an unexpected sample: %+v", sample)
+	}
+}
+
+func TestAddSampleWrongCpuUsage(t *testing.T) {
+	cpuPrevUsage := uint64(15)
+	cpuCurrentUsage := uint64(10)
+	memCurrentUsage := uint64(200)
+	prevTime := time.Now()
+
+	prev := createStats(cpuPrevUsage, memCurrentUsage, prevTime)
+	current := createStats(cpuCurrentUsage, memCurrentUsage, prevTime.Add(1*time.Second))
+
+	sample, err := NewSample(prev, current)
+	if err == nil {
+		t.Errorf("generated an unexpected sample: %+v", sample)
+	}
+}

third_party/src/github.com/google/cadvisor/info/machine.go

@@ -0,0 +1,42 @@
+// 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 info
+
+type MachineInfo struct {
+	// The number of cores in this machine.
+	NumCores int `json:"num_cores"`
+
+	// The amount of memory (in bytes) in this machine
+	MemoryCapacity int64 `json:"memory_capacity"`
+}
+
+type VersionInfo struct {
+	// Kernel version.
+	KernelVersion string `json:"kernel_version"`
+
+	// OS image being used for cadvisor container, or host image if running on host directly.
+	ContainerOsVersion string `json:"container_os_version"`
+
+	// Docker version.
+	DockerVersion string `json:"docker_version"`
+
+	// cAdvisor version.
+	CadvisorVersion string `json:"cadvisor_version"`
+}
+
+type MachineInfoFactory interface {
+	GetMachineInfo() (*MachineInfo, error)
+	GetVersionInfo() (*VersionInfo, error)
+}

third_party/src/github.com/google/cadvisor/info/version.go

@@ -0,0 +1,18 @@
+// 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 info
+
+// Version of cAdvisor.
+const VERSION = "0.1.0"

third_party/src/github.com/google/cadvisor/manager/container.go

@@ -0,0 +1,174 @@
+// 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.
+
+// Per-container manager.
+
+package manager
+
+import (
+	"fmt"
+	"log"
+	"sync"
+	"time"
+
+	"github.com/google/cadvisor/container"
+	"github.com/google/cadvisor/info"
+	"github.com/google/cadvisor/storage"
+)
+
+// Internal mirror of the external data structure.
+type containerStat struct {
+	Timestamp time.Time
+	Data      *info.ContainerStats
+}
+type containerInfo struct {
+	info.ContainerReference
+	Subcontainers []info.ContainerReference
+	Spec          *info.ContainerSpec
+}
+
+type containerData struct {
+	handler       container.ContainerHandler
+	info          containerInfo
+	storageDriver storage.StorageDriver
+	lock          sync.Mutex
+
+	// Tells the container to stop.
+	stop chan bool
+}
+
+func (c *containerData) Start() error {
+	// Force the first update.
+	c.housekeepingTick()
+	log.Printf("Start housekeeping for container %q\n", c.info.Name)
+
+	go c.housekeeping()
+	return nil
+}
+
+func (c *containerData) Stop() error {
+	c.stop <- true
+	return nil
+}
+
+func (c *containerData) GetInfo() (*containerInfo, error) {
+	// TODO(vmarmol): Consider caching this.
+	// Get spec and subcontainers.
+	err := c.updateSpec()
+	if err != nil {
+		return nil, err
+	}
+	err = c.updateSubcontainers()
+	if err != nil {
+		return nil, err
+	}
+
+	// Make a copy of the info for the user.
+	c.lock.Lock()
+	defer c.lock.Unlock()
+	ret := c.info
+	return &ret, nil
+}
+
+func NewContainerData(containerName string, driver storage.StorageDriver) (*containerData, error) {
+	if driver == nil {
+		return nil, fmt.Errorf("nil storage driver")
+	}
+	cont := &containerData{}
+	handler, err := container.NewContainerHandler(containerName)
+	if err != nil {
+		return nil, err
+	}
+	cont.handler = handler
+	ref, err := handler.ContainerReference()
+	if err != nil {
+		return nil, err
+	}
+	cont.info.Name = ref.Name
+	cont.info.Aliases = ref.Aliases
+	cont.storageDriver = driver
+	cont.stop = make(chan bool, 1)
+
+	return cont, nil
+}
+
+func (c *containerData) housekeeping() {
+	// Housekeep every second.
+	ticker := time.NewTicker(1 * time.Second)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-c.stop:
+			// Stop housekeeping when signaled.
+			return
+		case <-ticker.C:
+			start := time.Now()
+			c.housekeepingTick()
+
+			// Log if housekeeping took longer than 120ms.
+			duration := time.Since(start)
+			if duration >= 120*time.Millisecond {
+				log.Printf("Housekeeping(%s) took %s", c.info.Name, duration)
+			}
+		}
+	}
+}
+
+func (c *containerData) housekeepingTick() {
+	err := c.updateStats()
+	if err != nil {
+		log.Printf("Failed to update stats for container \"%s\": %s", c.info.Name, err)
+	}
+}
+
+func (c *containerData) updateSpec() error {
+	spec, err := c.handler.GetSpec()
+	if err != nil {
+		return err
+	}
+	c.lock.Lock()
+	defer c.lock.Unlock()
+	c.info.Spec = spec
+	return nil
+}
+
+func (c *containerData) updateStats() error {
+	stats, err := c.handler.GetStats()
+	if err != nil {
+		return err
+	}
+	if stats == nil {
+		return nil
+	}
+	ref, err := c.handler.ContainerReference()
+	if err != nil {
+		return err
+	}
+	err = c.storageDriver.AddStats(ref, stats)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func (c *containerData) updateSubcontainers() error {
+	subcontainers, err := c.handler.ListContainers(container.LIST_SELF)
+	if err != nil {
+		return err
+	}
+	c.lock.Lock()
+	defer c.lock.Unlock()
+	c.info.Subcontainers = subcontainers
+	return nil
+}

third_party/src/github.com/google/cadvisor/manager/machine.go

@@ -0,0 +1,127 @@
+// 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 manager
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"regexp"
+	"strconv"
+	"strings"
+	"syscall"
+
+	dclient "github.com/fsouza/go-dockerclient"
+	"github.com/google/cadvisor/container/docker"
+	"github.com/google/cadvisor/info"
+)
+
+var numCpuRegexp = regexp.MustCompile("processor\\t*: +[0-9]+")
+var memoryCapacityRegexp = regexp.MustCompile("MemTotal: *([0-9]+) kB")
+
+func getMachineInfo() (*info.MachineInfo, error) {
+	// Get the number of CPUs from /proc/cpuinfo.
+	out, err := ioutil.ReadFile("/proc/cpuinfo")
+	if err != nil {
+		return nil, err
+	}
+	numCores := len(numCpuRegexp.FindAll(out, -1))
+	if numCores == 0 {
+		return nil, fmt.Errorf("failed to count cores in output: %s", string(out))
+	}
+
+	// Get the amount of usable memory from /proc/meminfo.
+	out, err = ioutil.ReadFile("/proc/meminfo")
+	if err != nil {
+		return nil, err
+	}
+	matches := memoryCapacityRegexp.FindSubmatch(out)
+	if len(matches) != 2 {
+		return nil, fmt.Errorf("failed to find memory capacity in output: %s", string(out))
+	}
+	memoryCapacity, err := strconv.ParseInt(string(matches[1]), 10, 64)
+	if err != nil {
+		return nil, err
+	}
+
+	// Capacity is in KB, convert it to bytes.
+	memoryCapacity = memoryCapacity * 1024
+
+	return &info.MachineInfo{
+		NumCores:       numCores,
+		MemoryCapacity: memoryCapacity,
+	}, nil
+}
+
+func getVersionInfo() (*info.VersionInfo, error) {
+
+	kernel_version := getKernelVersion()
+	container_os := getContainerOsVersion()
+	docker_version := getDockerVersion()
+
+	return &info.VersionInfo{
+		KernelVersion:      kernel_version,
+		ContainerOsVersion: container_os,
+		DockerVersion:      docker_version,
+		CadvisorVersion:    info.VERSION,
+	}, nil
+}
+
+func getContainerOsVersion() string {
+	container_os := "Unknown"
+	os_release, err := ioutil.ReadFile("/etc/os-release")
+	if err == nil {
+		// We might be running in a busybox or some hand-crafted image.
+		// It's useful to know why cadvisor didn't come up.
+		for _, line := range strings.Split(string(os_release), "\n") {
+			parsed := strings.Split(line, "\"")
+			if len(parsed) == 3 && parsed[0] == "PRETTY_NAME=" {
+				container_os = parsed[1]
+				break
+			}
+		}
+	}
+	return container_os
+}
+
+func getDockerVersion() string {
+	docker_version := "Unknown"
+	client, err := dclient.NewClient(*docker.ArgDockerEndpoint)
+	if err == nil {
+		version, err := client.Version()
+		if err == nil {
+			docker_version = version.Get("Version")
+		}
+	}
+	return docker_version
+}
+
+func getKernelVersion() string {
+	uname := &syscall.Utsname{}
+
+	if err := syscall.Uname(uname); err != nil {
+		return "Unknown"
+	}
+
+	release := make([]byte, len(uname.Release))
+	i := 0
+	for _, c := range uname.Release {
+		release[i] = byte(c)
+		i++
+	}
+	release = release[:bytes.IndexByte(release, 0)]
+
+	return string(release)
+}

third_party/src/github.com/google/cadvisor/manager/manager.go

@@ -0,0 +1,300 @@
+// 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 manager
+
+import (
+	"fmt"
+	"log"
+	"sync"
+	"time"
+
+	"github.com/google/cadvisor/container"
+	"github.com/google/cadvisor/info"
+	"github.com/google/cadvisor/storage"
+)
+
+type Manager interface {
+	// Start the manager, blocks forever.
+	Start() error
+
+	// Get information about a container.
+	GetContainerInfo(containerName string) (*info.ContainerInfo, error)
+
+	// Get information about the machine.
+	GetMachineInfo() (*info.MachineInfo, error)
+
+	// Get version information about different components we depend on.
+	GetVersionInfo() (*info.VersionInfo, error)
+}
+
+func New(driver storage.StorageDriver) (Manager, error) {
+	if driver == nil {
+		return nil, fmt.Errorf("nil storage driver!")
+	}
+	newManager := &manager{}
+	newManager.containers = make(map[string]*containerData)
+
+	machineInfo, err := getMachineInfo()
+	if err != nil {
+		return nil, err
+	}
+	newManager.machineInfo = *machineInfo
+	log.Printf("Machine: %+v", newManager.machineInfo)
+
+	versionInfo, err := getVersionInfo()
+	if err != nil {
+		return nil, err
+	}
+	newManager.versionInfo = *versionInfo
+	log.Printf("Version: %+v", newManager.versionInfo)
+	newManager.storageDriver = driver
+
+	return newManager, nil
+}
+
+type manager struct {
+	containers     map[string]*containerData
+	containersLock sync.RWMutex
+	storageDriver  storage.StorageDriver
+	machineInfo    info.MachineInfo
+	versionInfo    info.VersionInfo
+}
+
+// Start the container manager.
+func (m *manager) Start() error {
+	// Create root and then recover all containers.
+	_, err := m.createContainer("/")
+	if err != nil {
+		return err
+	}
+	log.Printf("Starting recovery of all containers")
+	err = m.detectContainers()
+	if err != nil {
+		return err
+	}
+	log.Printf("Recovery completed")
+
+	// Look for new containers in the main housekeeping thread.
+	for t := range time.Tick(time.Second) {
+		start := time.Now()
+
+		// Check for new containers.
+		err = m.detectContainers()
+		if err != nil {
+			log.Printf("Failed to detect containers: %s", err)
+		}
+
+		// Log if housekeeping took more than 100ms.
+		duration := time.Since(start)
+		if duration >= 100*time.Millisecond {
+			log.Printf("Global Housekeeping(%d) took %s", t.Unix(), duration)
+		}
+	}
+	return nil
+}
+
+// Get a container by name.
+func (m *manager) GetContainerInfo(containerName string) (*info.ContainerInfo, error) {
+	log.Printf("Get(%s)", containerName)
+	var cont *containerData
+	var ok bool
+	func() {
+		m.containersLock.RLock()
+		defer m.containersLock.RUnlock()
+
+		// Ensure we have the container.
+		cont, ok = m.containers[containerName]
+	}()
+	if !ok {
+		return nil, fmt.Errorf("unknown container \"%s\"", containerName)
+	}
+
+	// Get the info from the container.
+	cinfo, err := cont.GetInfo()
+	if err != nil {
+		return nil, err
+	}
+
+	var percentiles *info.ContainerStatsPercentiles
+	var samples []*info.ContainerStatsSample
+	var stats []*info.ContainerStats
+	// TODO(monnand): These numbers should not be hard coded
+	percentiles, err = m.storageDriver.Percentiles(
+		cinfo.Name,
+		[]int{50, 80, 90, 99},
+		[]int{50, 80, 90, 99},
+	)
+	if err != nil {
+		return nil, err
+	}
+	samples, err = m.storageDriver.Samples(cinfo.Name, 1024)
+	if err != nil {
+		return nil, err
+	}
+
+	stats, err = m.storageDriver.RecentStats(cinfo.Name, 1024)
+	if err != nil {
+		return nil, err
+	}
+
+	// Make a copy of the info for the user.
+	ret := &info.ContainerInfo{
+		ContainerReference: info.ContainerReference{
+			Name:    cinfo.Name,
+			Aliases: cinfo.Aliases,
+		},
+		Subcontainers:    cinfo.Subcontainers,
+		Spec:             cinfo.Spec,
+		StatsPercentiles: percentiles,
+		Samples:          samples,
+		Stats:            stats,
+	}
+
+	// Set default value to an actual value
+	if ret.Spec.Memory != nil {
+		// Memory.Limit is 0 means there's no limit
+		if ret.Spec.Memory.Limit == 0 {
+			ret.Spec.Memory.Limit = uint64(m.machineInfo.MemoryCapacity)
+		}
+	}
+	return ret, nil
+}
+
+func (m *manager) GetMachineInfo() (*info.MachineInfo, error) {
+	// Copy and return the MachineInfo.
+	ret := m.machineInfo
+	return &ret, nil
+}
+
+func (m *manager) GetVersionInfo() (*info.VersionInfo, error) {
+	ret := m.versionInfo
+	return &ret, nil
+}
+
+// Create a container. This expects to only be called from the global manager thread.
+func (m *manager) createContainer(containerName string) (*containerData, error) {
+	cont, err := NewContainerData(containerName, m.storageDriver)
+	if err != nil {
+		return nil, err
+	}
+
+	// Add to the containers map.
+	func() {
+		m.containersLock.Lock()
+		defer m.containersLock.Unlock()
+
+		// Add the container name and all its aliases.
+		m.containers[containerName] = cont
+		for _, alias := range cont.info.Aliases {
+			m.containers[alias] = cont
+		}
+	}()
+	log.Printf("Added container: %s (aliases: %s)", containerName, cont.info.Aliases)
+
+	// Start the container's housekeeping.
+	cont.Start()
+	return cont, nil
+}
+
+func (m *manager) destroyContainer(containerName string) error {
+	m.containersLock.Lock()
+	defer m.containersLock.Unlock()
+
+	cont, ok := m.containers[containerName]
+	if !ok {
+		return fmt.Errorf("Expected container \"%s\" to exist during destroy", containerName)
+	}
+
+	// Tell the container to stop.
+	err := cont.Stop()
+	if err != nil {
+		return err
+	}
+
+	// Remove the container from our records (and all its aliases).
+	delete(m.containers, containerName)
+	for _, alias := range cont.info.Aliases {
+		delete(m.containers, alias)
+	}
+	log.Printf("Destroyed container: %s (aliases: %s)", containerName, cont.info.Aliases)
+	return nil
+}
+
+// Detect all containers that have been added or deleted.
+func (m *manager) getContainersDiff() (added []info.ContainerReference, removed []info.ContainerReference, err error) {
+	// TODO(vmarmol): We probably don't need to lock around / since it will always be there.
+	m.containersLock.RLock()
+	defer m.containersLock.RUnlock()
+
+	// Get all containers on the system.
+	cont, ok := m.containers["/"]
+	if !ok {
+		return nil, nil, fmt.Errorf("Failed to find container \"/\" while checking for new containers")
+	}
+	allContainers, err := cont.handler.ListContainers(container.LIST_RECURSIVE)
+	if err != nil {
+		return nil, nil, err
+	}
+	allContainers = append(allContainers, info.ContainerReference{Name: "/"})
+
+	// Determine which were added and which were removed.
+	allContainersSet := make(map[string]*containerData)
+	for name, d := range m.containers {
+		// Only add the canonical name.
+		if d.info.Name == name {
+			allContainersSet[name] = d
+		}
+	}
+	for _, c := range allContainers {
+		delete(allContainersSet, c.Name)
+		_, ok := m.containers[c.Name]
+		if !ok {
+			added = append(added, c)
+		}
+	}
+
+	// Removed ones are no longer in the container listing.
+	for _, d := range allContainersSet {
+		removed = append(removed, d.info.ContainerReference)
+	}
+
+	return
+}
+
+// Detect the existing containers and reflect the setup here.
+func (m *manager) detectContainers() error {
+	added, removed, err := m.getContainersDiff()
+	if err != nil {
+		return err
+	}
+
+	// Add the new containers.
+	for _, container := range added {
+		_, err = m.createContainer(container.Name)
+		if err != nil {
+			return fmt.Errorf("Failed to create existing container: %s: %s", container.Name, err)
+		}
+	}
+
+	// Remove the old containers.
+	for _, container := range removed {
+		err = m.destroyContainer(container.Name)
+		if err != nil {
+			return fmt.Errorf("Failed to destroy existing container: %s: %s", container.Name, err)
+		}
+	}
+
+	return nil
+}

third_party/src/github.com/google/cadvisor/pages/containers.go

@@ -0,0 +1,222 @@
+// 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.
+
+// Page for /containers/
+package pages
+
+import (
+	"fmt"
+	"html/template"
+	"log"
+	"net/http"
+	"net/url"
+	"path"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/google/cadvisor/info"
+	"github.com/google/cadvisor/manager"
+)
+
+const ContainersPage = "/containers/"
+
+var funcMap = template.FuncMap{
+	"containerLink":         containerLink,
+	"printMask":             printMask,
+	"printCores":            printCores,
+	"printMegabytes":        printMegabytes,
+	"getMemoryUsage":        getMemoryUsage,
+	"getMemoryUsagePercent": getMemoryUsagePercent,
+	"getHotMemoryPercent":   getHotMemoryPercent,
+	"getColdMemoryPercent":  getColdMemoryPercent,
+}
+
+// TODO(vmarmol): Consider housekeeping Spec too so we can show changes through time. We probably don't need it ever second though.
+
+var pageTemplate *template.Template
+
+type pageData struct {
+	ContainerName      string
+	ParentContainers   []info.ContainerReference
+	Subcontainers      []info.ContainerReference
+	Spec               *info.ContainerSpec
+	Stats              []*info.ContainerStats
+	MachineInfo        *info.MachineInfo
+	ResourcesAvailable bool
+	CpuAvailable       bool
+	MemoryAvailable    bool
+}
+
+func init() {
+	pageTemplate = template.New("containersTemplate").Funcs(funcMap)
+	_, err := pageTemplate.Parse(containersHtmlTemplate)
+	if err != nil {
+		log.Fatalf("Failed to parse template: %s", err)
+	}
+}
+
+// TODO(vmarmol): Escape this correctly.
+func containerLink(container info.ContainerReference, basenameOnly bool, cssClasses string) interface{} {
+	var displayName string
+	containerName := container.Name
+	if len(container.Aliases) > 0 {
+		displayName = container.Aliases[0]
+	} else if basenameOnly {
+		displayName = path.Base(string(container.Name))
+	} else {
+		displayName = string(container.Name)
+	}
+	if container.Name == "root" {
+		containerName = "/"
+	} else if strings.Contains(container.Name, " ") {
+		// If it has a space, it is an a.k.a, so keep the base-name
+		containerName = container.Name[:strings.Index(container.Name, " ")]
+	}
+	return template.HTML(fmt.Sprintf("<a class=\"%s\" href=\"%s%s\">%s</a>", cssClasses, ContainersPage[:len(ContainersPage)-1], containerName, displayName))
+}
+
+func printMask(mask *info.CpuSpecMask, numCores int) interface{} {
+	// TODO(vmarmol): Detect this correctly.
+	// TODO(vmarmol): Support more than 64 cores.
+	rawMask := uint64(0)
+	if len(mask.Data) > 0 {
+		rawMask = mask.Data[0]
+	}
+	masks := make([]string, numCores)
+	for i := uint(0); i < uint(numCores); i++ {
+		coreClass := "inactive-cpu"
+		// by default, all cores are active
+		if ((0x1<<i)&rawMask) != 0 || len(mask.Data) == 0 {
+			coreClass = "active-cpu"
+		}
+		masks[i] = fmt.Sprintf("<span class=\"%s\">%d</span>", coreClass, i)
+	}
+	return template.HTML(strings.Join(masks, "&nbsp;"))
+}
+
+func printCores(millicores *uint64) string {
+	// TODO(vmarmol): Detect this correctly
+	if *millicores > 1024*1000 {
+		return "unlimited"
+	}
+	cores := float64(*millicores) / 1000
+	return strconv.FormatFloat(cores, 'f', 3, 64)
+}
+
+func toMegabytes(bytes uint64) float64 {
+	return float64(bytes) / (1 << 20)
+}
+
+func printMegabytes(bytes uint64) string {
+	// TODO(vmarmol): Detect this correctly
+	if bytes > (100 << 30) {
+		return "unlimited"
+	}
+	megabytes := toMegabytes(bytes)
+	return strconv.FormatFloat(megabytes, 'f', 3, 64)
+}
+
+func toMemoryPercent(usage uint64, spec *info.ContainerSpec, machine *info.MachineInfo) int {
+	// Saturate limit to the machine size.
+	limit := uint64(spec.Memory.Limit)
+	if limit > uint64(machine.MemoryCapacity) {
+		limit = uint64(machine.MemoryCapacity)
+	}
+
+	return int((usage * 100) / limit)
+}
+
+func getMemoryUsage(stats []*info.ContainerStats) string {
+	return strconv.FormatFloat(toMegabytes((stats[len(stats)-1].Memory.Usage)), 'f', 2, 64)
+}
+
+func getMemoryUsagePercent(spec *info.ContainerSpec, stats []*info.ContainerStats, machine *info.MachineInfo) int {
+	return toMemoryPercent((stats[len(stats)-1].Memory.Usage), spec, machine)
+}
+
+func getHotMemoryPercent(spec *info.ContainerSpec, stats []*info.ContainerStats, machine *info.MachineInfo) int {
+	return toMemoryPercent((stats[len(stats)-1].Memory.WorkingSet), spec, machine)
+}
+
+func getColdMemoryPercent(spec *info.ContainerSpec, stats []*info.ContainerStats, machine *info.MachineInfo) int {
+	latestStats := stats[len(stats)-1].Memory
+	return toMemoryPercent((latestStats.Usage)-(latestStats.WorkingSet), spec, machine)
+}
+
+func ServerContainersPage(m manager.Manager, w http.ResponseWriter, u *url.URL) error {
+	start := time.Now()
+
+	// The container name is the path after the handler
+	containerName := u.Path[len(ContainersPage)-1:]
+
+	// Get the container.
+	cont, err := m.GetContainerInfo(containerName)
+	if err != nil {
+		return fmt.Errorf("Failed to get container \"%s\" with error: %s", containerName, err)
+	}
+
+	// Get the MachineInfo
+	machineInfo, err := m.GetMachineInfo()
+	if err != nil {
+		return err
+	}
+
+	// Make a list of the parent containers and their links
+	var parentContainers []info.ContainerReference
+	parentContainers = append(parentContainers, info.ContainerReference{Name: "root"})
+	parentName := ""
+	for _, part := range strings.Split(string(cont.Name), "/") {
+		if part == "" {
+			continue
+		}
+		parentName += "/" + part
+		parentContainers = append(parentContainers, info.ContainerReference{Name: parentName})
+	}
+
+	// Pick the shortest name of the container as the display name.
+	displayName := cont.Name
+	for _, alias := range cont.Aliases {
+		if len(displayName) >= len(alias) {
+			displayName = alias
+		}
+	}
+
+	// Replace the last part of the parent containers with the displayName.
+	if displayName != cont.Name {
+		parentContainers[len(parentContainers)-1] = info.ContainerReference{
+			Name: fmt.Sprintf("%s (%s)", displayName, path.Base(cont.Name)),
+		}
+	}
+
+	data := &pageData{
+		ContainerName: displayName,
+		// TODO(vmarmol): Only use strings for this.
+		ParentContainers:   parentContainers,
+		Subcontainers:      cont.Subcontainers,
+		Spec:               cont.Spec,
+		Stats:              cont.Stats,
+		MachineInfo:        machineInfo,
+		ResourcesAvailable: cont.Spec.Cpu != nil || cont.Spec.Memory != nil,
+		CpuAvailable:       cont.Spec.Cpu != nil,
+		MemoryAvailable:    cont.Spec.Memory != nil,
+	}
+	err = pageTemplate.Execute(w, data)
+	if err != nil {
+		log.Printf("Failed to apply template: %s", err)
+	}
+
+	log.Printf("Request took %s", time.Since(start))
+	return nil
+}

third_party/src/github.com/google/cadvisor/pages/containers_html.go

@@ -0,0 +1,160 @@
+// 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 pages
+
+const containersHtmlTemplate = `
+<html>
+<head>
+  <title>cAdvisor - Container {{.ContainerName}}</title>
+  <!-- Latest compiled and minified CSS -->
+  <link rel="stylesheet" href="//netdna.bootstrapcdn.com/bootstrap/3.1.1/css/bootstrap.min.css">
+
+  <!-- Optional theme -->
+  <link rel="stylesheet" href="//netdna.bootstrapcdn.com/bootstrap/3.1.1/css/bootstrap-theme.min.css">
+
+  <link rel="stylesheet" href="/static/containers.css">
+
+  <!-- Latest compiled and minified JavaScript -->
+  <script src="//ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js"></script>
+  <script src="//netdna.bootstrapcdn.com/bootstrap/3.1.1/js/bootstrap.min.js"></script>
+  <script type="text/javascript" src="https://www.google.com/jsapi"></script>
+
+  <script type="text/javascript" src="/static/containers.js"></script>
+</head>
+<body>
+<div class="container theme-showcase" >
+  <div class="col-sm-12" id="logo">
+  </div>
+  <div class="col-sm-12">
+  <div class="page-header">
+    <h1>{{.ContainerName}}</h1>
+  </div>
+  <ol class="breadcrumb">
+    {{range $parentContainer := .ParentContainers}}
+      <li>{{containerLink $parentContainer true ""}}</li>
+    {{end}}
+  </ol>
+  </div>
+  {{if .Subcontainers}}
+  <div class="col-sm-12">
+    <div class="page-header">
+      <h3>Subcontainers</h3>
+    </div>
+    <div class="list-group">
+      {{range $subcontainer := .Subcontainers}}
+        {{containerLink $subcontainer false "list-group-item"}}
+      {{end}}
+    </div>
+  </div>
+  {{end}}
+  {{if .ResourcesAvailable}}
+  <div class="col-sm-12">
+    <div class="page-header">
+      <h3>Isolation</h3>
+    </div>
+    {{if .CpuAvailable}}
+      <ul class="list-group">
+        <li class="list-group-item active isolation-title panel-title">CPU</li>
+        {{if .Spec.Cpu.Limit}}
+          <li class="list-group-item"><span class="stat-label">Limit</span> {{printCores .Spec.Cpu.Limit}} <span class="unit-label">cores</span></li>
+        {{end}}
+        {{if .Spec.Cpu.MaxLimit}}
+          <li class="list-group-item"><span class="stat-label">Max Limit</span> {{printCores .Spec.Cpu.MaxLimit}} <span class="unit-label">cores</span></li>
+        {{end}}
+        {{if .Spec.Cpu.Mask}}
+          <li class="list-group-item"><span class="stat-label">Allowed Cores</span> {{printMask .Spec.Cpu.Mask .MachineInfo.NumCores}}</li>
+        {{end}}
+      </ul>
+    {{end}}
+    {{if .MemoryAvailable}}
+      <ul class="list-group">
+        <li class="list-group-item active isolation-title panel-title">Memory</li>
+        {{if .Spec.Memory.Reservation}}
+          <li class="list-group-item"><span class="stat-label">Reservation</span> {{printMegabytes .Spec.Memory.Reservation}} <span class="unit-label">MB</span></li>
+        {{end}}
+        {{if .Spec.Memory.Limit}}
+          <li class="list-group-item"><span class="stat-label">Limit</span> {{printMegabytes .Spec.Memory.Limit}} <span class="unit-label">MB</span></li>
+        {{end}}
+        {{if .Spec.Memory.SwapLimit}}
+          <li class="list-group-item"><span class="stat-label">Swap Limit</span> {{printMegabytes .Spec.Memory.SwapLimit}} <span class="unit-label">MB</span></li>
+        {{end}}
+      </ul>
+    {{end}}
+  </div>
+  <div class="col-sm-12">
+    <div class="page-header">
+      <h3>Usage</h3>
+    </div>
+      <div class="panel panel-primary">
+        <div class="panel-heading">
+          <h3 class="panel-title">Overview</h3>
+        </div>
+        <div id="usage-gauge" class="panel-body">
+        </div>
+      </div>
+    {{if .CpuAvailable}}
+      <div class="panel panel-primary">
+        <div class="panel-heading">
+          <h3 class="panel-title">CPU</h3>
+        </div>
+        <div class="panel-body">
+          <h4>Total Usage</h4>
+	  <div id="cpu-total-usage-chart"></div>
+          <h4>Usage per Core</h4>
+	  <div id="cpu-per-core-usage-chart"></div>
+          <h4>Usage Breakdown</h4>
+	  <div id="cpu-usage-breakdown-chart"></div>
+        </div>
+      </div>
+    {{end}}
+    {{if .MemoryAvailable}}
+      <div class="panel panel-primary">
+        <div class="panel-heading">
+          <h3 class="panel-title">Memory</h3>
+        </div>
+        <div class="panel-body">
+          <h4>Total Usage</h4>
+	  <div id="memory-usage-chart"></div>
+          <br/>
+          <div class="row col-sm-12">
+            <h4>Usage Breakdown</h4>
+            <div class="col-sm-9">
+              <div class="progress">
+                <div class="progress-bar progress-bar-danger" style="width: {{getHotMemoryPercent .Spec .Stats .MachineInfo}}%">
+                  <span class="sr-only">Hot Memory</span>
+                </div>
+                <div class="progress-bar progress-bar-info" style="width: {{getColdMemoryPercent .Spec .Stats .MachineInfo}}%">
+                  <span class="sr-only">Cold Memory</span>
+                </div>
+              </div>
+            </div>
+            <div class="col-sm-3">
+              {{ getMemoryUsage .Stats }} MB ({{ getMemoryUsagePercent .Spec .Stats .MachineInfo}}%)
+            </div>
+	  </div>
+          <h4>Page Faults</h4>
+	  <div id="memory-page-faults-chart"></div>
+        </div>
+      </div>
+    {{end}}
+  </div>
+  {{end}}
+</div>
+<script type="text/javascript">
+  startPage({{.ContainerName}}, {{.CpuAvailable}}, {{.MemoryAvailable}});
+</script>
+</body>
+</html>
+`

third_party/src/github.com/google/cadvisor/pages/static/containers_js.go

@@ -0,0 +1,295 @@
+// 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 static
+
+const containersJs = `
+google.load("visualization", "1", {packages: ["corechart", "gauge"]});
+
+// Draw a line chart.
+function drawLineChart(seriesTitles, data, elementId, unit) {
+	// Convert the first column to a Date.
+	for (var i = 0; i < data.length; i++) {
+		if (data[i] != null) {
+			data[i][0] = new Date(data[i][0]);
+		}
+	}
+
+	// Add the definition of each column and the necessary data.
+	var dataTable = new google.visualization.DataTable();
+	dataTable.addColumn('datetime', seriesTitles[0]);
+	for (var i = 1; i < seriesTitles.length; i++) {
+		dataTable.addColumn('number', seriesTitles[i]);
+	}
+	dataTable.addRows(data);
+
+	// Create and draw the visualization.
+	var ac = null;
+	var opts = null;
+	// TODO(vmarmol): Remove this hack, it is to support the old charts and the new charts during the transition.
+	if (window.charts) {
+		if (!(elementId in window.charts)) {
+			ac = new google.visualization.LineChart(document.getElementById(elementId));
+			window.charts[elementId] = ac;
+		}
+		ac = window.charts[elementId];
+		opts = window.chartOptions;
+	} else {
+		ac = new google.visualization.LineChart(document.getElementById(elementId));
+		opts = {};
+	}
+	opts.vAxis = {title: unit};
+	opts.legend = {position: 'bottom'};
+	ac.draw(dataTable, window.chartOptions);
+}
+
+// Draw a gauge.
+function drawGauge(elementId, cpuUsage, memoryUsage) {
+	var gauges = [['Label', 'Value']];
+	if (cpuUsage >= 0) {
+		gauges.push(['CPU', cpuUsage]);
+	}
+	if (memoryUsage >= 0) {
+		gauges.push(['Memory', memoryUsage]);
+	}
+	// Create and populate the data table.
+	var data = google.visualization.arrayToDataTable(gauges);
+	
+	// Create and draw the visualization.
+	var options = {
+		width: 400, height: 120,
+		redFrom: 90, redTo: 100,
+		yellowFrom:75, yellowTo: 90,
+		minorTicks: 5,
+		animation: {
+			duration: 900,
+			easing: 'linear'
+		}
+	};
+	var chart = new google.visualization.Gauge(document.getElementById(elementId));
+	chart.draw(data, options);
+}
+
+// Get the machine info.
+function getMachineInfo(callback) {
+	$.getJSON("/api/v1.0/machine", function(data) {
+		callback(data);
+	});
+}
+
+// Get the container stats for the specified container.
+function getStats(containerName, callback) {
+	$.getJSON("/api/v1.0/containers" + containerName, function(data) {
+		callback(data);
+	});
+}
+
+// Draw the graph for CPU usage.
+function drawCpuTotalUsage(elementId, machineInfo, stats) {
+	var titles = ["Time", "Total"];
+	var data = [];
+	for (var i = 1; i < stats.stats.length; i++) {
+		var cur = stats.stats[i];
+		var prev = stats.stats[i - 1];
+
+		// TODO(vmarmol): This assumes we sample every second, use the timestamps.
+		var elements = [];
+		elements.push(cur.timestamp);
+		elements.push((cur.cpu.usage.total - prev.cpu.usage.total) / 1000000000);
+		data.push(elements);
+	}
+	drawLineChart(titles, data, elementId, "Cores");
+}
+
+// Draw the graph for per-core CPU usage.
+function drawCpuPerCoreUsage(elementId, machineInfo, stats) {
+	// Add a title for each core.
+	var titles = ["Time"];
+	for (var i = 0; i < machineInfo.num_cores; i++) {
+		titles.push("Core " + i);
+	}
+	var data = [];
+	for (var i = 1; i < stats.stats.length; i++) {
+		var cur = stats.stats[i];
+		var prev = stats.stats[i - 1];
+
+		var elements = [];
+		elements.push(cur.timestamp);
+		for (var j = 0; j < machineInfo.num_cores; j++) {
+			// TODO(vmarmol): This assumes we sample every second, use the timestamps.
+			elements.push((cur.cpu.usage.per_cpu[j] - prev.cpu.usage.per_cpu[j]) / 1000000000);
+		}
+		data.push(elements);
+	}
+	drawLineChart(titles, data, elementId, "Cores");
+}
+
+// Draw the graph for CPU usage breakdown.
+function drawCpuUsageBreakdown(elementId, containerInfo) {
+	var titles = ["Time", "User", "Kernel"];
+	var data = [];
+	for (var i = 1; i < containerInfo.stats.length; i++) {
+		var cur = containerInfo.stats[i];
+		var prev = containerInfo.stats[i - 1];
+
+		// TODO(vmarmol): This assumes we sample every second, use the timestamps.
+		var elements = [];
+		elements.push(cur.timestamp);
+		elements.push((cur.cpu.usage.user - prev.cpu.usage.user) / 1000000000);
+		elements.push((cur.cpu.usage.system - prev.cpu.usage.system) / 1000000000);
+		data.push(elements);
+	}
+	drawLineChart(titles, data, elementId, "Cores");
+}
+
+// Draw the gauges for overall resource usage.
+function drawOverallUsage(elementId, machineInfo, containerInfo) {
+	var cur = containerInfo.stats[containerInfo.stats.length - 1];
+
+	var cpuUsage = 0;
+	if (containerInfo.spec.cpu && containerInfo.stats.length >= 2) {
+		var prev = containerInfo.stats[containerInfo.stats.length - 2];
+		var rawUsage = cur.cpu.usage.total - prev.cpu.usage.total;
+
+		// Convert to millicores and take the percentage
+		cpuUsage = Math.round(((rawUsage / 1000000) / containerInfo.spec.cpu.limit) * 100);
+		if (cpuUsage > 100) {
+			cpuUsage = 100;
+		}
+	}
+
+	var memoryUsage = 0;
+	if (containerInfo.spec.memory) {
+		// Saturate to the machine size.
+		var limit = containerInfo.spec.memory.limit;
+		if (limit > machineInfo.memory_capacity) {
+			limit = machineInfo.memory_capacity;
+		}
+
+		memoryUsage = Math.round((cur.memory.usage / limit) * 100);
+	}
+
+	drawGauge(elementId, cpuUsage, memoryUsage);
+}
+
+var oneMegabyte = 1024 * 1024;
+
+function drawMemoryUsage(elementId, containerInfo) {
+	var titles = ["Time", "Total"];
+	var data = [];
+	for (var i = 0; i < containerInfo.stats.length; i++) {
+		var cur = containerInfo.stats[i];
+
+		// TODO(vmarmol): This assumes we sample every second, use the timestamps.
+		var elements = [];
+		elements.push(cur.timestamp);
+		elements.push(cur.memory.usage / oneMegabyte);
+		data.push(elements);
+	}
+	drawLineChart(titles, data, elementId, "Megabytes");
+}
+
+function drawMemoryPageFaults(elementId, containerInfo) {
+	var titles = ["Time", "Faults", "Major Faults"];
+	var data = [];
+	for (var i = 1; i < containerInfo.stats.length; i++) {
+		var cur = containerInfo.stats[i];
+		var prev = containerInfo.stats[i - 1];
+
+		// TODO(vmarmol): This assumes we sample every second, use the timestamps.
+		var elements = [];
+		elements.push(cur.timestamp);
+		elements.push(cur.memory.hierarchical_data.pgfault - prev.memory.hierarchical_data.pgfault);
+		// TODO(vmarmol): Fix to expose this data.
+		//elements.push(cur.memory.hierarchical_data.pgmajfault - prev.memory.hierarchical_data.pgmajfault);
+		elements.push(0);
+		data.push(elements);
+	}
+	drawLineChart(titles, data, elementId, "Faults");
+}
+
+// Expects an array of closures to call. After each execution the JS runtime is given control back before continuing.
+// This function returns asynchronously
+function stepExecute(steps) {
+	// No steps, stop.
+	if (steps.length == 0) {
+		return;
+	}
+
+	// Get a step and execute it.
+	var step = steps.shift();
+	step();
+
+	// Schedule the next step.
+	setTimeout(function() {
+		stepExecute(steps);
+	}, 0);
+}
+
+// Draw all the charts on the page.
+function drawCharts(machineInfo, containerInfo) {
+	var steps = [];
+
+	steps.push(function() {
+		drawOverallUsage("usage-gauge", machineInfo, containerInfo)
+	});
+
+	// CPU.
+	steps.push(function() {
+		drawCpuTotalUsage("cpu-total-usage-chart", machineInfo, containerInfo);
+	});
+	steps.push(function() {
+		drawCpuPerCoreUsage("cpu-per-core-usage-chart", machineInfo, containerInfo);
+	});
+	steps.push(function() {
+		drawCpuUsageBreakdown("cpu-usage-breakdown-chart", containerInfo);
+	});
+
+	// Memory.
+	steps.push(function() {
+		drawMemoryUsage("memory-usage-chart", containerInfo);
+	});
+	steps.push(function() {
+		drawMemoryPageFaults("memory-page-faults-chart", containerInfo);
+	});
+
+	stepExecute(steps);
+}
+
+// Executed when the page finishes loading.
+function startPage(containerName, hasCpu, hasMemory) {
+	// Don't fetch data if we don't have any resource.
+	if (!hasCpu && !hasMemory) {
+		return;
+	}
+
+	// TODO(vmarmol): Look into changing the view window to get a smoother animation.
+	window.chartOptions = {
+		curveType: 'function',
+		height: 300,
+		legend:{position:"none"},
+		focusTarget: "category",
+	};
+	window.charts = {};
+
+	// Get machine info, then get the stats every 1s.
+	getMachineInfo(function(machineInfo) {
+		setInterval(function() {
+			getStats(containerName, function(stats){
+				drawCharts(machineInfo, stats);
+			});
+		}, 1000);
+	});
+}
+`

third_party/src/github.com/google/cadvisor/pages/static/static.go

@@ -0,0 +1,46 @@
+// 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.
+
+// Handler for /static content.
+
+package static
+
+import (
+	"fmt"
+	"net/http"
+	"net/url"
+)
+
+const StaticResource = "/static/"
+
+var staticFiles = map[string]string{
+	"containers.css": containersCss,
+	"containers.js":  containersJs,
+}
+
+func HandleRequest(w http.ResponseWriter, u *url.URL) error {
+	if len(u.Path) <= len(StaticResource) {
+		return fmt.Errorf("unknown static resource %q", u.Path)
+	}
+
+	// Get the static content if it exists.
+	resource := u.Path[len(StaticResource):]
+	content, ok := staticFiles[resource]
+	if !ok {
+		return fmt.Errorf("unknown static resource %q", resource)
+	}
+
+	_, err := w.Write([]byte(content))
+	return err
+}

third_party/src/github.com/google/cadvisor/sampling/autofilter.go

@@ -0,0 +1,51 @@
+// 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 sampling
+
+type autoFilterSampler struct {
+	// filter will run to remove elements before adding every observation
+	filter  func(d interface{}) bool
+	sampler Sampler
+}
+
+func (self *autoFilterSampler) Len() int {
+	return self.sampler.Len()
+}
+
+func (self *autoFilterSampler) Reset() {
+	self.sampler.Reset()
+}
+
+func (self *autoFilterSampler) Map(f func(d interface{})) {
+	self.sampler.Map(f)
+}
+
+func (self *autoFilterSampler) Filter(filter func(d interface{}) bool) {
+	self.sampler.Filter(filter)
+}
+
+func (self *autoFilterSampler) Update(d interface{}) {
+	self.Filter(self.filter)
+	self.sampler.Update(d)
+}
+
+// Add a decorator for sampler. Whenever an Update() is called, the sampler will
+// call filter() first to remove elements in the decorated sampler.
+func NewAutoFilterSampler(sampler Sampler, filter func(d interface{}) bool) Sampler {
+	return &autoFilterSampler{
+		filter:  filter,
+		sampler: sampler,
+	}
+}

third_party/src/github.com/google/cadvisor/sampling/autoreset.go

@@ -0,0 +1,60 @@
+// 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 sampling
+
+import "time"
+
+type autoResetSampler struct {
+	shouldReset func(d interface{}) bool
+	sampler     Sampler
+}
+
+func (self *autoResetSampler) Len() int {
+	return self.sampler.Len()
+}
+
+func (self *autoResetSampler) Reset() {
+	self.sampler.Reset()
+}
+
+func (self *autoResetSampler) Map(f func(d interface{})) {
+	self.sampler.Map(f)
+}
+
+func (self *autoResetSampler) Filter(filter func(d interface{}) bool) {
+	self.sampler.Filter(filter)
+}
+
+func (self *autoResetSampler) Update(d interface{}) {
+	if self.shouldReset(d) {
+		self.sampler.Reset()
+	}
+	self.sampler.Update(d)
+}
+
+func NewPeriodicallyResetSampler(period time.Duration, sampler Sampler) Sampler {
+	lastRest := time.Now()
+	shouldReset := func(d interface{}) bool {
+		if time.Now().Sub(lastRest) > period {
+			lastRest = time.Now()
+			return true
+		}
+		return false
+	}
+	return &autoResetSampler{
+		shouldReset: shouldReset,
+		sampler:     sampler,
+	}
+}

third_party/src/github.com/google/cadvisor/sampling/chainsample.go

@@ -0,0 +1,171 @@
+// 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 sampling
+
+import (
+	"log"
+	"math/rand"
+	"sync"
+
+	"github.com/kr/pretty"
+)
+
+type empty struct{}
+
+// Randomly generate number [start,end) except @except.
+func randInt64Except(start, end int64, except map[int64]empty) int64 {
+	n := end - start
+	ret := rand.Int63n(n) + start
+	for _, ok := except[ret]; ok; _, ok = except[ret] {
+		ret = rand.Int63n(n) + start
+	}
+	return ret
+}
+
+// Basic idea:
+// Every observation will have a sequence number as its id.
+// Suppose we want to sample k observations within latest n observations
+// At first, we generated k random numbers in [0,n). These random numbers
+// will be used as ids of observations that will be sampled.
+type chainSampler struct {
+	sampleSize int
+	windowSize int64
+
+	// Every observation will have a sequence number starting from 1.
+	// The sequence number must increase by one for each observation.
+	numObservations int64
+
+	// All samples stored as id -> value.
+	samples map[int64]interface{}
+
+	// The set of id of future observations.
+	futureSamples map[int64]empty
+
+	// The chain of samples: old observation id -> future observation id.
+	// When the old observation expires, the future observation will be
+	// stored as a sample.
+	sampleChain map[int64]int64
+
+	// Replacements are: observations whose previous sample is not expired
+	// id->value.
+	replacements map[int64]interface{}
+	lock         sync.RWMutex
+}
+
+func (self *chainSampler) initFutureSamples() {
+	for i := 0; i < self.sampleSize; i++ {
+		n := randInt64Except(1, self.windowSize+1, self.futureSamples)
+		self.futureSamples[n] = empty{}
+	}
+}
+
+func (self *chainSampler) arrive(seqNum int64, obv interface{}) {
+	if _, ok := self.futureSamples[seqNum]; !ok {
+		// If this observation is not selected, ignore it.
+		return
+	}
+
+	delete(self.futureSamples, seqNum)
+
+	if len(self.samples) < self.sampleSize {
+		self.samples[seqNum] = obv
+	}
+	self.replacements[seqNum] = obv
+
+	// Select a future observation which will replace current observation
+	// when it expires.
+	futureSeqNum := randInt64Except(seqNum+1, seqNum+self.windowSize+1, self.futureSamples)
+	self.futureSamples[futureSeqNum] = empty{}
+	self.sampleChain[seqNum] = futureSeqNum
+}
+
+func (self *chainSampler) expireAndReplace() {
+	expSeqNum := self.numObservations - self.windowSize
+	if _, ok := self.samples[expSeqNum]; !ok {
+		// No sample expires
+		return
+	}
+	delete(self.samples, expSeqNum)
+	// There must be a replacement, otherwise panic.
+	replacementSeqNum := self.sampleChain[expSeqNum]
+	// The sequence number must increase by one for each observation.
+	replacement, ok := self.replacements[replacementSeqNum]
+	if !ok {
+		log.Printf("cannot find %v. which is the replacement of %v\n", replacementSeqNum, expSeqNum)
+		pretty.Printf("chain: %# v\n", self)
+		panic("Should never occur!")
+	}
+	// This observation must have arrived before.
+	self.samples[replacementSeqNum] = replacement
+}
+
+func (self *chainSampler) Update(obv interface{}) {
+	self.lock.Lock()
+	defer self.lock.Unlock()
+
+	self.numObservations++
+	self.arrive(self.numObservations, obv)
+	self.expireAndReplace()
+}
+
+func (self *chainSampler) Len() int {
+	self.lock.RLock()
+	defer self.lock.RUnlock()
+	return len(self.samples)
+}
+
+func (self *chainSampler) Reset() {
+	self.lock.Lock()
+	defer self.lock.Unlock()
+	self.numObservations = 0
+	self.samples = make(map[int64]interface{}, self.sampleSize)
+	self.futureSamples = make(map[int64]empty, self.sampleSize*2)
+	self.sampleChain = make(map[int64]int64, self.sampleSize*2)
+	self.replacements = make(map[int64]interface{}, self.sampleSize*2)
+	self.initFutureSamples()
+}
+
+func (self *chainSampler) Map(f func(d interface{})) {
+	self.lock.RLock()
+	defer self.lock.RUnlock()
+
+	for seqNum, obv := range self.samples {
+		if _, ok := obv.(int); !ok {
+			pretty.Printf("Seq %v. WAT: %# v\n", seqNum, obv)
+		}
+		f(obv)
+	}
+}
+
+// NOT SUPPORTED
+func (self *chainSampler) Filter(filter func(d interface{}) bool) {
+	return
+}
+
+// Chain sampler described in
+// Brian Babcok, Mayur Datar and Rajeev Motwani,
+// Sampling From a Moving Window Over Streaming Data
+func NewChainSampler(sampleSize, windowSize int) Sampler {
+	sampler := &chainSampler{
+		sampleSize:    sampleSize,
+		windowSize:    int64(windowSize),
+		samples:       make(map[int64]interface{}, sampleSize),
+		futureSamples: make(map[int64]empty, sampleSize*2),
+		sampleChain:   make(map[int64]int64, sampleSize*2),
+		replacements:  make(map[int64]interface{}, sampleSize*2),
+	}
+	sampler.initFutureSamples()
+	return sampler
+}

third_party/src/github.com/google/cadvisor/sampling/chainsample_test.go

@@ -0,0 +1,43 @@
+// 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 sampling
+
+import "testing"
+
+func TestChainSampler(t *testing.T) {
+	numSamples := 10
+	windowSize := 10 * numSamples
+	numObservations := 10 * windowSize
+	numSampleRounds := 10 * numObservations
+
+	s := NewChainSampler(numSamples, windowSize)
+	hist := make(map[int]int, numSamples)
+	for i := 0; i < numSampleRounds; i++ {
+		sampleStream(hist, numObservations, s)
+	}
+	ratio := histStddev(hist) / histMean(hist)
+	if ratio > 1.05 {
+		// XXX(dengnan): better sampler?
+		t.Errorf("std dev: %v; mean: %v. Either we have a really bad PRNG, or a bad implementation", histStddev(hist), histMean(hist))
+	}
+	if len(hist) > windowSize {
+		t.Errorf("sampled %v data. larger than window size %v", len(hist), windowSize)
+	}
+	for seqNum, freq := range hist {
+		if seqNum < numObservations-windowSize && freq > 0 {
+			t.Errorf("observation with seqnum %v is sampled %v times", seqNum, freq)
+		}
+	}
+}

third_party/src/github.com/google/cadvisor/sampling/doc.go

@@ -0,0 +1,17 @@
+// 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 sampling provides several sampling algorithms.
+// These algorithms will be used to sample containers' stats information
+package sampling

third_party/src/github.com/google/cadvisor/sampling/es.go

@@ -0,0 +1,143 @@
+// 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 sampling
+
+import (
+	"container/heap"
+	"math"
+	"math/rand"
+	"sync"
+)
+
+type esSampleItem struct {
+	data interface{}
+	key  float64
+}
+
+type esSampleHeap []esSampleItem
+
+func (self esSampleHeap) Len() int {
+	return len(self)
+}
+
+func (self esSampleHeap) Less(i, j int) bool {
+	return self[i].key < self[j].key
+}
+
+func (self esSampleHeap) Swap(i, j int) {
+	self[i], self[j] = self[j], self[i]
+}
+
+func (self *esSampleHeap) Push(x interface{}) {
+	item := x.(esSampleItem)
+	*self = append(*self, item)
+}
+
+func (self *esSampleHeap) Pop() interface{} {
+	old := *self
+	item := old[len(old)-1]
+	*self = old[:len(old)-1]
+	return item
+}
+
+type esSampler struct {
+	weight  func(interface{}) float64
+	samples *esSampleHeap
+	maxSize int
+	lock    sync.RWMutex
+}
+
+func (self *esSampler) Update(d interface{}) {
+	self.lock.Lock()
+	defer self.lock.Unlock()
+
+	u := rand.Float64()
+	key := math.Pow(u, 1.0/self.weight(d))
+
+	if self.samples.Len() < self.maxSize {
+		heap.Push(self.samples, esSampleItem{
+			data: d,
+			key:  key,
+		})
+		return
+	}
+
+	s := *(self.samples)
+	min := s[0]
+
+	// The key of the new item is larger than a key in existing item.
+	// Add this new item.
+	if key > min.key {
+		heap.Pop(self.samples)
+		heap.Push(self.samples, esSampleItem{
+			data: d,
+			key:  key,
+		})
+	}
+}
+
+func (self *esSampler) Len() int {
+	self.lock.RLock()
+	defer self.lock.RUnlock()
+	return len(*self.samples)
+}
+
+func (self *esSampler) Reset() {
+	self.lock.Lock()
+	defer self.lock.Unlock()
+	self.samples = &esSampleHeap{}
+	heap.Init(self.samples)
+}
+
+func (self *esSampler) Map(f func(interface{})) {
+	self.lock.RLock()
+	defer self.lock.RUnlock()
+
+	for _, d := range *self.samples {
+		f(d.data)
+	}
+}
+
+func (self *esSampler) Filter(filter func(d interface{}) bool) {
+	self.lock.Lock()
+	defer self.lock.Unlock()
+
+	rmlist := make([]int, 0, len(*self.samples))
+	for i, d := range *self.samples {
+		if filter(d.data) {
+			rmlist = append(rmlist, i)
+		}
+	}
+
+	for _, i := range rmlist {
+		heap.Remove(self.samples, i)
+	}
+}
+
+// ES sampling algorithm described in
+//
+// Pavlos S. Efraimidis and Paul G. Spirakis. Weighted random sampling with a
+// reservoir. Information Processing Letters, 97(5):181 – 185, 2006.
+//
+// http://dl.acm.org/citation.cfm?id=1138834
+func NewESSampler(size int, weight func(interface{}) float64) Sampler {
+	s := &esSampleHeap{}
+	heap.Init(s)
+	return &esSampler{
+		maxSize: size,
+		samples: s,
+		weight:  weight,
+	}
+}

third_party/src/github.com/google/cadvisor/sampling/es_test.go

@@ -0,0 +1,81 @@
+// 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 sampling
+
+import (
+	"container/heap"
+	"math/rand"
+	"testing"
+
+	"github.com/kr/pretty"
+)
+
+// This should be a min heap
+func TestESSampleHeap(t *testing.T) {
+	h := &esSampleHeap{}
+	heap.Init(h)
+	min := 5.0
+	N := 10
+
+	for i := 0; i < N; i++ {
+		key := rand.Float64()
+		if key < min {
+			min = key
+		}
+		heap.Push(h, esSampleItem{nil, key})
+	}
+	l := *h
+	if l[0].key != min {
+		t.Errorf("not a min heap")
+		pretty.Printf("min=%v\nheap=%# v\n", min, l)
+	}
+}
+
+func TestESSampler(t *testing.T) {
+	reservoirSize := 10
+	numObvs := 10 * reservoirSize
+	numSampleRounds := 100 * numObvs
+
+	weight := func(d interface{}) float64 {
+		n := d.(int)
+		return float64(n + 1)
+	}
+	s := NewESSampler(reservoirSize, weight)
+	hist := make(map[int]int, numObvs)
+	for i := 0; i < numSampleRounds; i++ {
+		sampleStream(hist, numObvs, s)
+	}
+
+	diff := 2
+	wrongOrderedItems := make([]int, 0, numObvs)
+	threshold := 1.05
+	for i := 0; i < numObvs-diff; i++ {
+		// Item with smaller weight should have lower probability to be selected.
+		n1 := hist[i]
+		n2 := hist[i+diff]
+		if n1 > n2 {
+			if float64(n1) > float64(n2)*threshold {
+				wrongOrderedItems = append(wrongOrderedItems, i)
+			}
+		}
+	}
+	if float64(len(wrongOrderedItems)) > float64(numObvs)*0.05 {
+		for _, i := range wrongOrderedItems {
+			n1 := hist[i]
+			n2 := hist[i+diff]
+			t.Errorf("item with weight %v is selected %v times; while item with weight %v is selected %v times", i, n1, i+diff, n2)
+		}
+	}
+}

third_party/src/github.com/google/cadvisor/sampling/reservoir.go

@@ -0,0 +1,99 @@
+// 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 sampling
+
+import (
+	"math/rand"
+	"sync"
+)
+
+// Reservoir sampling algorithm.
+// http://en.wikipedia.org/wiki/Reservoir_sampling
+type reservoirSampler struct {
+	maxSize      int
+	samples      []interface{}
+	numInstances int64
+	lock         sync.RWMutex
+}
+
+func (self *reservoirSampler) Len() int {
+	self.lock.RLock()
+	defer self.lock.RUnlock()
+	return len(self.samples)
+}
+
+func (self *reservoirSampler) Reset() {
+	self.lock.Lock()
+	defer self.lock.Unlock()
+	self.samples = make([]interface{}, 0, self.maxSize)
+	self.numInstances = 0
+}
+
+// Update samples according to http://en.wikipedia.org/wiki/Reservoir_sampling
+func (self *reservoirSampler) Update(d interface{}) {
+	self.lock.Lock()
+	defer self.lock.Unlock()
+
+	self.numInstances++
+	if len(self.samples) < self.maxSize {
+		self.samples = append(self.samples, d)
+		return
+	}
+	// Randomly generates a number between [0, numInstances).
+	// Use this random number, j, as an index.  If j is larger than the
+	// reservoir size, we will ignore the current new data.
+	// Otherwise replace the jth element in reservoir with the new data.
+	j := rand.Int63n(self.numInstances)
+	if j < int64(len(self.samples)) {
+		self.samples[int(j)] = d
+	}
+}
+
+func (self *reservoirSampler) Map(f func(d interface{})) {
+	self.lock.RLock()
+	defer self.lock.RUnlock()
+
+	for _, d := range self.samples {
+		f(d)
+	}
+}
+
+// Once an element is removed, the probability of sampling an observation will
+// be increased.  Removing all elements in the sampler has the same effect as
+// calling Reset(). However, it will not guarantee the uniform probability of
+// all unfiltered samples.
+func (self *reservoirSampler) Filter(filter func(d interface{}) bool) {
+	self.lock.Lock()
+	defer self.lock.Unlock()
+	rmlist := make([]int, 0, len(self.samples))
+	for i, d := range self.samples {
+		if filter(d) {
+			rmlist = append(rmlist, i)
+		}
+	}
+
+	for _, i := range rmlist {
+		// slice trick: remove the ith element without preserving the order
+		self.samples[i] = self.samples[len(self.samples)-1]
+		self.samples = self.samples[:len(self.samples)-1]
+	}
+	self.numInstances -= int64(len(rmlist))
+}
+
+func NewReservoirSampler(reservoirSize int) Sampler {
+	return &reservoirSampler{
+		maxSize: reservoirSize,
+	}
+}

third_party/src/github.com/google/cadvisor/sampling/reservoir_test.go

@@ -0,0 +1,70 @@
+// 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 sampling
+
+import (
+	"math"
+	"testing"
+)
+
+func sampleStream(hist map[int]int, n int, s Sampler) {
+	s.Reset()
+	for i := 0; i < n; i++ {
+		s.Update(i)
+	}
+	s.Map(func(d interface{}) {
+		j := d.(int)
+		if _, ok := hist[j]; !ok {
+			hist[j] = 0
+		}
+		hist[j]++
+	})
+}
+
+func histMean(hist map[int]int) float64 {
+	total := 0
+	for _, v := range hist {
+		total += v
+	}
+	return float64(total) / float64(len(hist))
+}
+
+func histStddev(hist map[int]int) float64 {
+	mean := histMean(hist)
+	var totalDiff float64
+	for _, v := range hist {
+		diff := float64(v) - mean
+		sq := diff * diff
+		totalDiff += sq
+	}
+	return math.Sqrt(totalDiff / float64(len(hist)))
+}
+
+// XXX(dengnan): This test may take more than 10 seconds.
+func TestReservoirSampler(t *testing.T) {
+	reservoirSize := 10
+	numSamples := 10 * reservoirSize
+	numSampleRounds := 100 * numSamples
+
+	s := NewReservoirSampler(reservoirSize)
+	hist := make(map[int]int, numSamples)
+	for i := 0; i < numSampleRounds; i++ {
+		sampleStream(hist, numSamples, s)
+	}
+	ratio := histStddev(hist) / histMean(hist)
+	if ratio > 0.05 {
+		t.Errorf("std dev: %v; mean: %v. Either we have a really bad PRNG, or a bad implementation", histStddev(hist), histMean(hist))
+	}
+}

third_party/src/github.com/google/cadvisor/sampling/sampler.go

@@ -0,0 +1,42 @@
+// 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 sampling
+
+import (
+	crand "crypto/rand"
+	"encoding/binary"
+	"math/rand"
+)
+
+func init() {
+	// NOTE(dengnan): Even if we picked a good random seed,
+	// the random number from math/rand is still not cryptographically secure!
+	var seed int64
+	binary.Read(crand.Reader, binary.LittleEndian, &seed)
+	rand.Seed(seed)
+}
+
+type Sampler interface {
+	Update(d interface{})
+	Len() int
+	Reset()
+	Map(f func(interface{}))
+
+	// Filter() should update in place. Removing elements may or may not
+	// affect the statistical behavior of the sampler, i.e. the probability
+	// that an observation will be sampled after removing some elements is
+	// implementation defined.
+	Filter(filter func(interface{}) bool)
+}

third_party/src/github.com/google/cadvisor/storage/memory/memory.go

@@ -0,0 +1,224 @@
+// 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 (
+	"container/list"
+	"fmt"
+	"sync"
+
+	"github.com/google/cadvisor/info"
+	"github.com/google/cadvisor/sampling"
+	"github.com/google/cadvisor/storage"
+)
+
+// containerStorage is used to store per-container information
+type containerStorage struct {
+	ref         info.ContainerReference
+	prevStats   *info.ContainerStats
+	sampler     sampling.Sampler
+	recentStats *list.List
+	maxNumStats int
+	maxMemUsage uint64
+	lock        sync.RWMutex
+}
+
+func (self *containerStorage) updatePrevStats(stats *info.ContainerStats) {
+	if stats == nil || stats.Cpu == nil || stats.Memory == nil {
+		// discard incomplete stats
+		self.prevStats = nil
+		return
+	}
+	if self.prevStats == nil {
+		self.prevStats = &info.ContainerStats{
+			Cpu:    &info.CpuStats{},
+			Memory: &info.MemoryStats{},
+		}
+	}
+	// make a deep copy.
+	self.prevStats.Timestamp = stats.Timestamp
+	*self.prevStats.Cpu = *stats.Cpu
+	self.prevStats.Cpu.Usage.PerCpu = make([]uint64, len(stats.Cpu.Usage.PerCpu))
+	for i, perCpu := range stats.Cpu.Usage.PerCpu {
+		self.prevStats.Cpu.Usage.PerCpu[i] = perCpu
+	}
+	*self.prevStats.Memory = *stats.Memory
+}
+
+func (self *containerStorage) AddStats(stats *info.ContainerStats) error {
+	self.lock.Lock()
+	defer self.lock.Unlock()
+	if self.prevStats != nil {
+		sample, err := info.NewSample(self.prevStats, stats)
+		if err != nil {
+			return fmt.Errorf("wrong stats: %v", err)
+		}
+		if sample != nil {
+			self.sampler.Update(sample)
+		}
+	}
+	if stats.Memory != nil {
+		if self.maxMemUsage < stats.Memory.Usage {
+			self.maxMemUsage = stats.Memory.Usage
+		}
+	}
+	if self.recentStats.Len() >= self.maxNumStats {
+		self.recentStats.Remove(self.recentStats.Front())
+	}
+	self.recentStats.PushBack(stats)
+	self.updatePrevStats(stats)
+	return nil
+}
+
+func (self *containerStorage) RecentStats(numStats int) ([]*info.ContainerStats, error) {
+	self.lock.RLock()
+	defer self.lock.RUnlock()
+	if self.recentStats.Len() < numStats || numStats < 0 {
+		numStats = self.recentStats.Len()
+	}
+	ret := make([]*info.ContainerStats, 0, numStats)
+	e := self.recentStats.Front()
+	for i := 0; i < numStats; i++ {
+		data, ok := e.Value.(*info.ContainerStats)
+		if !ok {
+			return nil, fmt.Errorf("The %vth element is not a ContainerStats", i)
+		}
+		ret = append(ret, data)
+		e = e.Next()
+		if e == nil {
+			break
+		}
+	}
+	return ret, nil
+}
+
+func (self *containerStorage) Samples(numSamples int) ([]*info.ContainerStatsSample, error) {
+	self.lock.RLock()
+	defer self.lock.RUnlock()
+	if self.sampler.Len() < numSamples || numSamples < 0 {
+		numSamples = self.sampler.Len()
+	}
+	ret := make([]*info.ContainerStatsSample, 0, numSamples)
+
+	var err error
+	self.sampler.Map(func(d interface{}) {
+		if len(ret) >= numSamples || err != nil {
+			return
+		}
+		sample, ok := d.(*info.ContainerStatsSample)
+		if !ok {
+			err = fmt.Errorf("An element in the sample is not a ContainerStatsSample")
+		}
+		ret = append(ret, sample)
+	})
+	if err != nil {
+		return nil, err
+	}
+	return ret, nil
+}
+
+func (self *containerStorage) Percentiles(cpuPercentiles, memPercentiles []int) (*info.ContainerStatsPercentiles, error) {
+	samples, err := self.Samples(-1)
+	if err != nil {
+		return nil, err
+	}
+	if len(samples) == 0 {
+		return nil, nil
+	}
+	ret := info.NewPercentiles(samples, cpuPercentiles, memPercentiles)
+	ret.MaxMemoryUsage = self.maxMemUsage
+	return ret, nil
+}
+
+func newContainerStore(ref info.ContainerReference, maxNumSamples, maxNumStats int) *containerStorage {
+	s := sampling.NewReservoirSampler(maxNumSamples)
+	return &containerStorage{
+		ref:         ref,
+		recentStats: list.New(),
+		sampler:     s,
+		maxNumStats: maxNumStats,
+	}
+}
+
+type InMemoryStorage struct {
+	lock                sync.RWMutex
+	containerStorageMap map[string]*containerStorage
+	maxNumSamples       int
+	maxNumStats         int
+}
+
+func (self *InMemoryStorage) AddStats(ref info.ContainerReference, stats *info.ContainerStats) error {
+	var cstore *containerStorage
+	var ok bool
+	self.lock.Lock()
+	if cstore, ok = self.containerStorageMap[ref.Name]; !ok {
+		cstore = newContainerStore(ref, self.maxNumSamples, self.maxNumStats)
+		self.containerStorageMap[ref.Name] = cstore
+	}
+	self.lock.Unlock()
+	return cstore.AddStats(stats)
+}
+
+func (self *InMemoryStorage) Samples(name string, numSamples int) ([]*info.ContainerStatsSample, error) {
+	var cstore *containerStorage
+	var ok bool
+	self.lock.RLock()
+	if cstore, ok = self.containerStorageMap[name]; !ok {
+		return nil, fmt.Errorf("unable to find data for container %v", name)
+	}
+	self.lock.RUnlock()
+
+	return cstore.Samples(numSamples)
+}
+
+func (self *InMemoryStorage) RecentStats(name string, numStats int) ([]*info.ContainerStats, error) {
+	var cstore *containerStorage
+	var ok bool
+	self.lock.RLock()
+	if cstore, ok = self.containerStorageMap[name]; !ok {
+		return nil, fmt.Errorf("unable to find data for container %v", name)
+	}
+	self.lock.RUnlock()
+
+	return cstore.RecentStats(numStats)
+}
+
+func (self *InMemoryStorage) Percentiles(name string, cpuPercentiles, memPercentiles []int) (*info.ContainerStatsPercentiles, error) {
+	var cstore *containerStorage
+	var ok bool
+	self.lock.RLock()
+	if cstore, ok = self.containerStorageMap[name]; !ok {
+		return nil, fmt.Errorf("unable to find data for container %v", name)
+	}
+	self.lock.RUnlock()
+
+	return cstore.Percentiles(cpuPercentiles, memPercentiles)
+}
+
+func (self *InMemoryStorage) Close() error {
+	self.lock.Lock()
+	self.containerStorageMap = make(map[string]*containerStorage, 32)
+	self.lock.Unlock()
+	return nil
+}
+
+func New(maxNumSamples, maxNumStats int) storage.StorageDriver {
+	ret := &InMemoryStorage{
+		containerStorageMap: make(map[string]*containerStorage, 32),
+		maxNumSamples:       maxNumSamples,
+		maxNumStats:         maxNumStats,
+	}
+	return ret
+}

third_party/src/github.com/google/cadvisor/storage/memory/memory_test.go

@@ -0,0 +1,49 @@
+// 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 (
+	"testing"
+
+	"github.com/google/cadvisor/storage"
+	"github.com/google/cadvisor/storage/test"
+)
+
+func runStorageTest(f func(storage.StorageDriver, *testing.T), t *testing.T) {
+	maxSize := 200
+
+	var driver storage.StorageDriver
+	for N := 10; N < maxSize; N += 10 {
+		driver = New(N, N)
+		f(driver, t)
+	}
+
+}
+
+func TestMaxMemoryUsage(t *testing.T) {
+	runStorageTest(test.StorageDriverTestMaxMemoryUsage, t)
+}
+
+func TestSampleCpuUsage(t *testing.T) {
+	runStorageTest(test.StorageDriverTestSampleCpuUsage, t)
+}
+
+func TestSamplesWithoutSample(t *testing.T) {
+	runStorageTest(test.StorageDriverTestSamplesWithoutSample, t)
+}
+
+func TestPercentilessWithoutSample(t *testing.T) {
+	runStorageTest(test.StorageDriverTestPercentilesWithoutSample, t)
+}

third_party/src/github.com/google/cadvisor/storage/storage.go

@@ -0,0 +1,40 @@
+// 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 storage
+
+import "github.com/google/cadvisor/info"
+
+type StorageDriver interface {
+	AddStats(ref info.ContainerReference, stats *info.ContainerStats) error
+
+	// Read most recent stats. numStats indicates max number of stats
+	// returned. The returned stats must be consecutive observed stats. If
+	// numStats < 0, then return all stats stored in the storage.
+	RecentStats(containerName string, numStats int) ([]*info.ContainerStats, error)
+
+	// Read the specified percentiles of CPU and memory usage of the container.
+	// The implementation decides which time range to look at.
+	Percentiles(containerName string, cpuUsagePercentiles []int, memUsagePercentiles []int) (*info.ContainerStatsPercentiles, error)
+
+	// Returns samples of the container stats. If numSamples < 0, then
+	// the number of returned samples is implementation defined. Otherwise, the driver
+	// should return at most numSamples samples.
+	Samples(containername string, numSamples int) ([]*info.ContainerStatsSample, error)
+
+	// Close will clear the state of the storage driver. The elements
+	// stored in the underlying storage may or may not be deleted depending
+	// on the implementation of the storage driver.
+	Close() error
+}

third_party/src/github.com/google/cadvisor/storage/test/storagetests.go

@@ -0,0 +1,170 @@
+// 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 test
+
+import (
+	"math/rand"
+	"testing"
+	"time"
+
+	"github.com/google/cadvisor/info"
+	"github.com/google/cadvisor/storage"
+)
+
+func buildTrace(cpu, mem []uint64, duration time.Duration) []*info.ContainerStats {
+	if len(cpu) != len(mem) {
+		panic("len(cpu) != len(mem)")
+	}
+
+	ret := make([]*info.ContainerStats, len(cpu))
+	currentTime := time.Now()
+
+	var cpuTotalUsage uint64 = 0
+	for i, cpuUsage := range cpu {
+		cpuTotalUsage += cpuUsage
+		stats := new(info.ContainerStats)
+		stats.Cpu = new(info.CpuStats)
+		stats.Memory = new(info.MemoryStats)
+		stats.Timestamp = currentTime
+		currentTime = currentTime.Add(duration)
+
+		stats.Cpu.Usage.Total = cpuTotalUsage
+		stats.Cpu.Usage.User = stats.Cpu.Usage.Total
+		stats.Cpu.Usage.System = 0
+
+		stats.Memory.Usage = mem[i]
+
+		ret[i] = stats
+	}
+	return ret
+}
+
+// The underlying driver must be able to hold more than 10 samples.
+func StorageDriverTestSampleCpuUsage(driver storage.StorageDriver, t *testing.T) {
+	defer driver.Close()
+	N := 10
+	cpuTrace := make([]uint64, 0, N)
+	memTrace := make([]uint64, 0, N)
+
+	// We need N+1 observations to get N samples
+	for i := 0; i < N+1; i++ {
+		cpuTrace = append(cpuTrace, uint64(rand.Intn(1000)))
+		memTrace = append(memTrace, uint64(rand.Intn(1000)))
+	}
+
+	samplePeriod := 1 * time.Second
+
+	ref := info.ContainerReference{
+		Name: "container",
+	}
+
+	trace := buildTrace(cpuTrace, memTrace, samplePeriod)
+
+	for _, stats := range trace {
+		driver.AddStats(ref, stats)
+	}
+
+	samples, err := driver.Samples(ref.Name, N)
+	if err != nil {
+		t.Errorf("unable to sample stats: %v", err)
+	}
+	for _, sample := range samples {
+		if sample.Duration != samplePeriod {
+			t.Errorf("sample duration is %v, not %v", sample.Duration, samplePeriod)
+		}
+		cpuUsage := sample.Cpu.Usage
+		found := false
+		for _, u := range cpuTrace {
+			if u == cpuUsage {
+				found = true
+			}
+		}
+		if !found {
+			t.Errorf("unable to find cpu usage %v", cpuUsage)
+		}
+	}
+}
+
+func StorageDriverTestMaxMemoryUsage(driver storage.StorageDriver, t *testing.T) {
+	defer driver.Close()
+	N := 100
+	memTrace := make([]uint64, N)
+	cpuTrace := make([]uint64, N)
+	for i := 0; i < N; i++ {
+		memTrace[i] = uint64(i + 1)
+		cpuTrace[i] = uint64(1)
+	}
+
+	ref := info.ContainerReference{
+		Name: "container",
+	}
+
+	trace := buildTrace(cpuTrace, memTrace, 1*time.Second)
+
+	for _, stats := range trace {
+		driver.AddStats(ref, stats)
+	}
+
+	percentiles, err := driver.Percentiles(ref.Name, []int{50}, []int{50})
+	if err != nil {
+		t.Errorf("unable to call Percentiles(): %v", err)
+	}
+	maxUsage := uint64(N)
+	if percentiles.MaxMemoryUsage != maxUsage {
+		t.Fatalf("Max memory usage should be %v; received %v", maxUsage, percentiles.MaxMemoryUsage)
+	}
+}
+
+func StorageDriverTestSamplesWithoutSample(driver storage.StorageDriver, t *testing.T) {
+	defer driver.Close()
+	trace := buildTrace(
+		[]uint64{10},
+		[]uint64{10},
+		1*time.Second)
+	ref := info.ContainerReference{
+		Name: "container",
+	}
+	driver.AddStats(ref, trace[0])
+	samples, err := driver.Samples(ref.Name, -1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(samples) != 0 {
+		t.Errorf("There should be no sample")
+	}
+}
+
+func StorageDriverTestPercentilesWithoutSample(driver storage.StorageDriver, t *testing.T) {
+	defer driver.Close()
+	trace := buildTrace(
+		[]uint64{10},
+		[]uint64{10},
+		1*time.Second)
+	ref := info.ContainerReference{
+		Name: "container",
+	}
+	driver.AddStats(ref, trace[0])
+	percentiles, err := driver.Percentiles(
+		ref.Name,
+		[]int{50},
+		[]int{50},
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if percentiles != nil {
+		t.Errorf("There should be no percentiles")
+	}
+}