cadvisor-0.25.0/000077500000000000000000000000001306035727200134155ustar00rootroot00000000000000cadvisor-0.25.0/.gitignore000066400000000000000000000000651306035727200154060ustar00rootroot00000000000000cadvisor /release .vscode # Go test binaries *.test cadvisor-0.25.0/.travis.yml000066400000000000000000000003171306035727200155270ustar00rootroot00000000000000language: go sudo: false go: - 1.5.3 install: - true before_script: - go get golang.org/x/tools/cmd/vet - go get github.com/kr/godep script: - export PATH=$PATH:$HOME/gopath/bin - ./build/presubmit.sh cadvisor-0.25.0/AUTHORS000066400000000000000000000004001306035727200144570ustar00rootroot00000000000000# This is the official list of cAdvisor authors for copyright purposes. # Names should be added to this file as # Name or Organization # The email address is not required for organizations. # Please keep the list sorted. Google Inc. cadvisor-0.25.0/CHANGELOG.md000066400000000000000000000220421306035727200152260ustar00rootroot00000000000000# Changelog ### 0.25.0 (2017-03-09) - Disable thin_ls due to excessive iops - Ignore .mount cgroups, fixing dissappearing stats - Fix wc goroutine leak - Update aws-sdk-go dependency to 1.6.10 - Update to go 1.7 for releases ### 0.24.1 (2016-10-10) - Fix issue with running cAdvisor in a container on some distributions. ### 0.24.0 (2016-09-19) - Added host-level inode stats (total & available) - Improved robustness to partial failures - Metrics collector improvements - Added ability to directly use endpoints from the container itself - Allow SSL endpoint access - Ability to provide a certificate which is exposed to custom endpoints - Lots of bug fixes, including: - Devicemapper thin_ls fixes - Prometheus metrics fixes - Fixes for missing stats (memory reservation, FS usage, etc.) ### 0.23.9 (2016-08-09) - Cherry-pick release: - Ensure minimum kernel version for thin_ls ### 0.23.8 (2016-08-02) - Cherry-pick release: - Prefix Docker labels & env vars in Prometheus metrics to prevent conflicts ### 0.23.7 (2016-07-18) - Cherry-pick release: - Modify working set memory stats calculation ### 0.23.6 (2016-06-23) - Cherry-pick release: - Updating inotify to fix memory leak v0.23 cherrypick ### 0.23.5 (2016-06-22) - Cherry-pick release: - support LVM based device mapper storage drivers ### 0.23.4 (2016-06-16) - Cherry-pick release: - Check for thin_is binary in path for devicemapper when using ThinPoolWatcher - Fix uint64 overflow issue for CPU stats ### 0.23.3 (2016-06-08) - Cherry-pick release: - Cap the maximum consecutive du commands - Fix a panic when a prometheus endpoint ends with a newline ### 0.23.2 (2016-05-18) - Handle kernel log rotation - More rkt support: poll rkt service for new containers - Better handling of partial failures when fetching subcontainers - Devicemapper thin_ls support (requires Device Mapper kernel module and supporting utilities) ### 0.23.1 (2016-05-11) - Add multi-container charts to the UI - Add TLS options for Kafka storage driver - Switch to official Docker client - Systemd: - Ignore .mount cgroups on systemd - Better OOM monitoring - Bug: Fix broken -disable_metrics flag - Bug: Fix openstack identified as AWS - Bug: Fix EventStore when limit is 0 ### 0.23.0 (2016-04-21) - Docker v1.11 support - Preliminary rkt support - Bug: Fix file descriptor leak ### 0.22.0 (2016-02-25) - Disk usage calculation bug fixes - Systemd integration bug fixes - Instance ID support for Azure and AWS - Limit number of custom metrics - Support opt out for disk and network metrics ### 0.21.0 (2016-02-03) - Support for filesystem stats with docker v1.10 - Bug fixes. ### 0.20.5 (2016-01-27) - Breaking: Use uint64 for memory stats - Bug: Fix devicemapper partition labelling - Bug: Fix network stats when using new Docker network functionality - Bug: Fix env var label mapping initialization - Dependencies: libcontainer update ### 0.20.4 (2016-01-20) - Godep updates ### 0.20.3 (2016-01-19) - Bug fixes - Jitter added to housekeeping to smooth CPU usage. ### 0.20.2 (2016-01-15) - New v2.1 API with better filesystem stats - Internal refactoring - Bug fixes. ### 0.18.0 (2015-09-23) - Large bunch of bug-fixes - Fixed networking stats for newer docker versions using libnetwork. - Added application-specific metrics ## 0.16.0 (2015-06-26) - Misc fixes. ## 0.15.1 (2015-06-10) - Fix longstanding memory leak. - Fix UI on newest Chrome. ## 0.15.0 (2015-06-08) - Expose multiple network intefaces in UI and API. - Add support for XFS. - Fixes in inotify watches. - Fixes on PowerPC machines. - Fixes for newer systems with systemd. - Extra debuging informaiton in /validate. ## 0.14.0 (2015-05-21) - Add process stats to container pages in the UI. - Serve UI from relative paths (allows reverse proxying). - Minor fixes to events API. - Add bytes available to FS info. - Adding Docker status and image information to UI. - Basic Redis storage backend. - Misc reliability improvements. ## 0.13.0 (2015-05-01) - Added `--docker_only` to limit monitoring to only Docker containers. - Added support for Docker labels. - Added limit for events storage. - Fixes for OOM event monitoring. - Changed event type to a string in the API. - Misc fixes. ## 0.12.0 (2015-04-15) - Added support for Docker 1.6. - Split OOM event into OOM kill and OOM. - Made EventData a concrete type in returned events. - Enabled CPU load tracking (experimental). ## 0.11.0 (2015-03-27) - Export all stats as [Prometheus](https://prometheus.io/) metrics. - Initial support for [events](docs/api.md): creation, deletion, and OOM. - Adding machine UUID information. - Beta release of the cAdvisor [2.0 API](docs/api_v2.md). - Improve handling of error conditions. - Misc fixes and improvements. ## 0.10.1 (2015-02-27) - Disable OOM monitoring which is using too much CPU. - Fix break in summary stats. ## 0.10.0 (2015-02-24) - Adding Start and End time for ContainerInfoRequest. - Various misc fixes. ## 0.9.0 (2015-02-06) - Support for more network devices (all non-eth). - Support for more partition types (btrfs, device-mapper, whole-disk). - Added reporting of DiskIO stats. - Adding container creation time to ContainerSpec. - More robust handling of stats failures. - Various misc fixes. ## 0.8.0 (2015-01-09) - Added ethernet device information. - Added machine-wide networking statistics. - Misc UI fixes. - Fixes for partially-isolated containers. ## 0.7.1 (2014-12-23) - Avoid repeated logging of container errors. - Handle non identify mounts for cgroups. ## 0.7.0 (2014-12-18) - Support for HTTP basic auth. - Added /validate to perform basic checks and determine support for cAdvisor. - All stats in the UI are now updated. - Added gauges for filesystem usage. - Added device information to machine info. - Fixes to container detection. - Fixes for systemd detection. - ContainerSpecs are now cached. - Performance improvements. ## 0.6.2 (2014-11-20) - Fixes for Docker API and UI endpoints. - Misc UI bugfixes. ## 0.6.1 (2014-11-18) - Bug fix in InfluxDB storage driver. Container name and hostname will be exported. ## 0.6.0 (2014-11-17) - Adding /docker UI endpoint for Docker containers. - Fixes around handling Docker containers. - Performance enhancements. - Embed all external dependencies. - ContainerStats Go struct has been flattened. The wire format remains unchanged. - Misc bugfixes and cleanups. ## 0.5.0 (2014-10-28) - Added disk space stats. On by default for root, available on AUFS Docker containers. - Introduced v1.2 remote API with new "docker" resource for Docker containers. - Added "ContainerHints" file based interface to inject extra information about containers. ## 0.4.1 (2014-09-29) - Support for Docker containers in systemd systems. - Adding DiskIO stats - Misc bugfixes and cleanups ## 0.4.0 (2014-09-19) - Various performance enhancements: brings CPU usage down 85%+ - Implemented dynamic sampling through dynamic housekeeping. - Memory storage driver is always on, BigQuery and InfluxDB are now optional storage backends. - Fix for DNS resolution crashes when contacting InfluxDB. - New containers are now detected using inotify. - Added pprof HTTP endpoint. - UI bugfixes. ## 0.3.0 (2014-09-05) - Support for Docker with LXC backend. - Added BigQuery storage driver. - Performance and stability fixes for InfluxDB storage driver. - UI fixes and improvements. - Configurable stats gathering interval (default: 1s). - Improvements to startup and CPU utilization. - Added /healthz endpoint for determining whether cAdvisor is healthy. - Bugfixes and performance improvements. ## 0.2.2 (2014-08-13) - Improvements to influxDB plugin. Table name is now 'stats'. Network stats added. Detailed cpu and memory stats are no longer exported to reduce the load on the DB. Docker container alias now exported - It is now possible to aggregate stats across multiple nodes. - Make the UI independent of the storage backend by caching recent stats in memory. - Switched to glog. - Bugfixes and performance improvements. - Introduced v1.1 remote API with new "subcontainers" resource. ## 0.2.1 (2014-07-25) - Handle old Docker versions. - UI fixes and other bugfixes. ## 0.2.0 (2014-07-24) - Added network stats to the UI. - Added support for CoreOS and RHEL. - Bugfixes and reliability fixes. ## 0.1.4 (2014-07-22) - Add network statistics to REST API. - Add "raw" driver to handle non-Docker containers. - Remove lmctfy in favor of the raw driver. - Bugfixes for Docker containers and logging. ## 0.1.3 (2014-07-14) - Add support for systemd systems. - Fixes for UI with InfluxDB storage driver. ## 0.1.2 (2014-07-10) - Added Storage Driver concept (flag: storage_driver), default is the in-memory driver - Implemented InfluxDB storage driver - Support in REST API for specifying number of stats to return - Allow running without lmctfy (flag: allow_lmctfy) - Bugfixes ## 0.1.0 (2014-06-14) - Support for container aliases - Sampling historical usage and exporting that in the REST API - Bugfixes for UI ## 0.0.0 (2014-06-10) - Initial version of cAdvisor - Web UI with auto-updating stats - v1.0 REST API with container and machine information - Support for Docker containers - Support for lmctfy containers cadvisor-0.25.0/CONTRIBUTING.md000066400000000000000000000015501306035727200156470ustar00rootroot00000000000000## 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. cadvisor-0.25.0/Godeps/000077500000000000000000000000001306035727200146365ustar00rootroot00000000000000cadvisor-0.25.0/Godeps/Godeps.json000066400000000000000000000443311306035727200167570ustar00rootroot00000000000000{ "ImportPath": "github.com/google/cadvisor", "GoVersion": "go1.6", "GodepVersion": "v74", "Packages": [ "./..." ], "Deps": [ { "ImportPath": "bitbucket.org/ww/goautoneg", "Comment": "null-5", "Rev": "'75cd24fc2f2c2a2088577d12123ddee5f54e0675'" }, { "ImportPath": "cloud.google.com/go/compute/metadata", "Comment": "v0.1.0-115-g3b1ae45", "Rev": "3b1ae45394a234c385be014e9a488f2bb6eef821" }, { "ImportPath": "cloud.google.com/go/internal", "Comment": "v0.1.0-115-g3b1ae45", "Rev": "3b1ae45394a234c385be014e9a488f2bb6eef821" }, { "ImportPath": "github.com/Microsoft/go-winio", "Comment": "v0.3.2", "Rev": "862b6557927a5c5c81e411c12aa6de7e566cbb7a" }, { "ImportPath": "github.com/SeanDolphin/bqschema", "Rev": "f92a08f515e1bf718e995076a37c2f534b1deb08" }, { "ImportPath": "github.com/Shopify/sarama", "Comment": "v1.8.0", "Rev": "4ba9bba6adb6697bcec3841e1ecdfecf5227c3b9" }, { "ImportPath": "github.com/Sirupsen/logrus", "Comment": "v0.7.3-2-g26709e2", "Rev": "26709e2714106fb8ad40b773b711ebce25b78914" }, { "ImportPath": "github.com/abbot/go-http-auth", "Rev": "c0ef4539dfab4d21c8ef20ba2924f9fc6f186d35" }, { "ImportPath": "github.com/aws/aws-sdk-go/aws", "Comment": "v1.6.10", "Rev": "63ce630574a5ec05ecd8e8de5cea16332a5a684d" }, { "ImportPath": "github.com/aws/aws-sdk-go/aws/awserr", "Comment": "v1.6.10", "Rev": "63ce630574a5ec05ecd8e8de5cea16332a5a684d" }, { "ImportPath": "github.com/aws/aws-sdk-go/aws/awsutil", "Comment": "v1.6.10", "Rev": "63ce630574a5ec05ecd8e8de5cea16332a5a684d" }, { "ImportPath": "github.com/aws/aws-sdk-go/aws/client", "Comment": "v1.6.10", "Rev": "63ce630574a5ec05ecd8e8de5cea16332a5a684d" }, { "ImportPath": "github.com/aws/aws-sdk-go/aws/client/metadata", "Comment": "v1.6.10", "Rev": "63ce630574a5ec05ecd8e8de5cea16332a5a684d" }, { "ImportPath": "github.com/aws/aws-sdk-go/aws/corehandlers", "Comment": "v1.6.10", "Rev": "63ce630574a5ec05ecd8e8de5cea16332a5a684d" }, { "ImportPath": "github.com/aws/aws-sdk-go/aws/credentials", "Comment": "v1.6.10", "Rev": "63ce630574a5ec05ecd8e8de5cea16332a5a684d" }, { "ImportPath": "github.com/aws/aws-sdk-go/aws/credentials/ec2rolecreds", "Comment": "v1.6.10", "Rev": "63ce630574a5ec05ecd8e8de5cea16332a5a684d" }, { "ImportPath": "github.com/aws/aws-sdk-go/aws/credentials/endpointcreds", "Comment": "v1.6.10", "Rev": "63ce630574a5ec05ecd8e8de5cea16332a5a684d" }, { "ImportPath": "github.com/aws/aws-sdk-go/aws/credentials/stscreds", "Comment": "v1.6.10", "Rev": "63ce630574a5ec05ecd8e8de5cea16332a5a684d" }, { "ImportPath": "github.com/aws/aws-sdk-go/aws/defaults", "Comment": "v1.6.10", "Rev": "63ce630574a5ec05ecd8e8de5cea16332a5a684d" }, { "ImportPath": "github.com/aws/aws-sdk-go/aws/ec2metadata", "Comment": "v1.6.10", "Rev": "63ce630574a5ec05ecd8e8de5cea16332a5a684d" }, { "ImportPath": "github.com/aws/aws-sdk-go/aws/endpoints", "Comment": "v1.6.10", "Rev": "63ce630574a5ec05ecd8e8de5cea16332a5a684d" }, { "ImportPath": "github.com/aws/aws-sdk-go/aws/request", "Comment": "v1.6.10", "Rev": "63ce630574a5ec05ecd8e8de5cea16332a5a684d" }, { "ImportPath": "github.com/aws/aws-sdk-go/aws/session", "Comment": "v1.6.10", "Rev": "63ce630574a5ec05ecd8e8de5cea16332a5a684d" }, { "ImportPath": "github.com/aws/aws-sdk-go/aws/signer/v4", "Comment": "v1.6.10", "Rev": "63ce630574a5ec05ecd8e8de5cea16332a5a684d" }, { "ImportPath": "github.com/aws/aws-sdk-go/private/protocol", "Comment": "v1.6.10", "Rev": "63ce630574a5ec05ecd8e8de5cea16332a5a684d" }, { "ImportPath": "github.com/aws/aws-sdk-go/private/protocol/query", "Comment": "v1.6.10", "Rev": "63ce630574a5ec05ecd8e8de5cea16332a5a684d" }, { "ImportPath": "github.com/aws/aws-sdk-go/private/protocol/query/queryutil", "Comment": "v1.6.10", "Rev": "63ce630574a5ec05ecd8e8de5cea16332a5a684d" }, { "ImportPath": "github.com/aws/aws-sdk-go/private/protocol/rest", "Comment": "v1.6.10", "Rev": "63ce630574a5ec05ecd8e8de5cea16332a5a684d" }, { "ImportPath": "github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil", "Comment": "v1.6.10", "Rev": "63ce630574a5ec05ecd8e8de5cea16332a5a684d" }, { "ImportPath": "github.com/aws/aws-sdk-go/service/sts", "Comment": "v1.6.10", "Rev": "63ce630574a5ec05ecd8e8de5cea16332a5a684d" }, { "ImportPath": "github.com/beorn7/perks/quantile", "Rev": "b965b613227fddccbfffe13eae360ed3fa822f8d" }, { "ImportPath": "github.com/blang/semver", "Comment": "v3.1.0", "Rev": "aea32c919a18e5ef4537bbd283ff29594b1b0165" }, { "ImportPath": "github.com/coreos/go-systemd/dbus", "Comment": "v8-2-g4484981", "Rev": "4484981625c1a6a2ecb40a390fcb6a9bcfee76e3" }, { "ImportPath": "github.com/coreos/go-systemd/util", "Comment": "v8-2-g4484981", "Rev": "4484981625c1a6a2ecb40a390fcb6a9bcfee76e3" }, { "ImportPath": "github.com/coreos/pkg/dlopen", "Comment": "v2", "Rev": "7f080b6c11ac2d2347c3cd7521e810207ea1a041" }, { "ImportPath": "github.com/coreos/rkt/api/v1alpha", "Comment": "v1.6.0", "Rev": "14437382a98e5ebeb6cafb57cff445370e3f7d56" }, { "ImportPath": "github.com/docker/distribution/digest", "Comment": "v2.4.0-rc.1-30-gc6f63e2", "Rev": "c6f63e298ebb1dd0a2ce5ada0c0d39e248132634" }, { "ImportPath": "github.com/docker/distribution/reference", "Comment": "v2.4.0-rc.1-30-gc6f63e2", "Rev": "c6f63e298ebb1dd0a2ce5ada0c0d39e248132634" }, { "ImportPath": "github.com/docker/docker/pkg/longpath", "Comment": "v1.11.2", "Rev": "b9f10c951893f9a00865890a5232e85d770c1087" }, { "ImportPath": "github.com/docker/docker/pkg/mount", "Comment": "v1.11.2", "Rev": "b9f10c951893f9a00865890a5232e85d770c1087" }, { "ImportPath": "github.com/docker/docker/pkg/symlink", "Comment": "v1.11.2", "Rev": "b9f10c951893f9a00865890a5232e85d770c1087" }, { "ImportPath": "github.com/docker/docker/pkg/system", "Comment": "v1.11.2", "Rev": "b9f10c951893f9a00865890a5232e85d770c1087" }, { "ImportPath": "github.com/docker/engine-api/client", "Comment": "v0.3.1-48-g87b3df2", "Rev": "87b3df23dcba0ce02bfe0474e29a08a97f7814e6" }, { "ImportPath": "github.com/docker/engine-api/client/transport", "Comment": "v0.3.1-48-g87b3df2", "Rev": "87b3df23dcba0ce02bfe0474e29a08a97f7814e6" }, { "ImportPath": "github.com/docker/engine-api/client/transport/cancellable", "Comment": "v0.3.1-48-g87b3df2", "Rev": "87b3df23dcba0ce02bfe0474e29a08a97f7814e6" }, { "ImportPath": "github.com/docker/engine-api/types", "Comment": "v0.3.1-48-g87b3df2", "Rev": "87b3df23dcba0ce02bfe0474e29a08a97f7814e6" }, { "ImportPath": "github.com/docker/engine-api/types/blkiodev", "Comment": "v0.3.1-48-g87b3df2", "Rev": "87b3df23dcba0ce02bfe0474e29a08a97f7814e6" }, { "ImportPath": "github.com/docker/engine-api/types/container", "Comment": "v0.3.1-48-g87b3df2", "Rev": "87b3df23dcba0ce02bfe0474e29a08a97f7814e6" }, { "ImportPath": "github.com/docker/engine-api/types/filters", "Comment": "v0.3.1-48-g87b3df2", "Rev": "87b3df23dcba0ce02bfe0474e29a08a97f7814e6" }, { "ImportPath": "github.com/docker/engine-api/types/network", "Comment": "v0.3.1-48-g87b3df2", "Rev": "87b3df23dcba0ce02bfe0474e29a08a97f7814e6" }, { "ImportPath": "github.com/docker/engine-api/types/reference", "Comment": "v0.3.1-48-g87b3df2", "Rev": "87b3df23dcba0ce02bfe0474e29a08a97f7814e6" }, { "ImportPath": "github.com/docker/engine-api/types/registry", "Comment": "v0.3.1-48-g87b3df2", "Rev": "87b3df23dcba0ce02bfe0474e29a08a97f7814e6" }, { "ImportPath": "github.com/docker/engine-api/types/strslice", "Comment": "v0.3.1-48-g87b3df2", "Rev": "87b3df23dcba0ce02bfe0474e29a08a97f7814e6" }, { "ImportPath": "github.com/docker/engine-api/types/time", "Comment": "v0.3.1-48-g87b3df2", "Rev": "87b3df23dcba0ce02bfe0474e29a08a97f7814e6" }, { "ImportPath": "github.com/docker/engine-api/types/versions", "Comment": "v0.3.1-48-g87b3df2", "Rev": "87b3df23dcba0ce02bfe0474e29a08a97f7814e6" }, { "ImportPath": "github.com/docker/go-connections/nat", "Comment": "v0.2.0-2-gf549a93", "Rev": "f549a9393d05688dff0992ef3efd8bbe6c628aeb" }, { "ImportPath": "github.com/docker/go-connections/sockets", "Comment": "v0.2.0-2-gf549a93", "Rev": "f549a9393d05688dff0992ef3efd8bbe6c628aeb" }, { "ImportPath": "github.com/docker/go-connections/tlsconfig", "Comment": "v0.2.0-2-gf549a93", "Rev": "f549a9393d05688dff0992ef3efd8bbe6c628aeb" }, { "ImportPath": "github.com/docker/go-units", "Comment": "v0.1.0-21-g0bbddae", "Rev": "0bbddae09c5a5419a8c6dcdd7ff90da3d450393b" }, { "ImportPath": "github.com/eapache/go-resiliency/breaker", "Comment": "v1.0.0-4-gb86b1ec", "Rev": "b86b1ec0dd4209a588dc1285cdd471e73525c0b3" }, { "ImportPath": "github.com/eapache/queue", "Comment": "v1.0.2", "Rev": "ded5959c0d4e360646dc9e9908cff48666781367" }, { "ImportPath": "github.com/garyburd/redigo/internal", "Rev": "535138d7bcd717d6531c701ef5933d98b1866257" }, { "ImportPath": "github.com/garyburd/redigo/redis", "Rev": "535138d7bcd717d6531c701ef5933d98b1866257" }, { "ImportPath": "github.com/go-ini/ini", "Comment": "v1.9.0", "Rev": "193d1ecb466bf97aae8b454a5cfc192941c64809" }, { "ImportPath": "github.com/godbus/dbus", "Comment": "v3", "Rev": "c7fdd8b5cd55e87b4e1f4e372cdb1db61dd6c66f" }, { "ImportPath": "github.com/golang/glog", "Rev": "fca8c8854093a154ff1eb580aae10276ad6b1b5f" }, { "ImportPath": "github.com/golang/protobuf/proto", "Rev": "b982704f8bb716bb608144408cff30e15fbde841" }, { "ImportPath": "github.com/golang/snappy", "Rev": "723cc1e459b8eea2dea4583200fd60757d40097a" }, { "ImportPath": "github.com/influxdb/influxdb/client", "Comment": "v0.9.5.1", "Rev": "9eab56311373ee6f788ae5dfc87e2240038f0eb4" }, { "ImportPath": "github.com/influxdb/influxdb/models", "Comment": "v0.9.5.1", "Rev": "9eab56311373ee6f788ae5dfc87e2240038f0eb4" }, { "ImportPath": "github.com/influxdb/influxdb/pkg/escape", "Comment": "v0.9.5.1", "Rev": "9eab56311373ee6f788ae5dfc87e2240038f0eb4" }, { "ImportPath": "github.com/jmespath/go-jmespath", "Comment": "0.2.2-12-g0b12d6b", "Rev": "0b12d6b521d83fc7f755e7cfc1b1fbdd35a01a74" }, { "ImportPath": "github.com/klauspost/crc32", "Rev": "a3b15ae34567abb20a22992b989cd76f48d09c47" }, { "ImportPath": "github.com/kr/pretty", "Comment": "go.weekly.2011-12-22-20-g088c856", "Rev": "088c856450c08c03eb32f7a6c221e6eefaa10e6f" }, { "ImportPath": "github.com/kr/text", "Rev": "6807e777504f54ad073ecef66747de158294b639" }, { "ImportPath": "github.com/matttproud/golang_protobuf_extensions/pbutil", "Rev": "fc2b8d3a73c4867e51861bbdd5ae3c1f0869dd6a" }, { "ImportPath": "github.com/mistifyio/go-zfs", "Comment": "v2.1.1-5-g1b4ae6f", "Rev": "1b4ae6fb4e77b095934d4430860ff202060169f8" }, { "ImportPath": "github.com/opencontainers/runc/libcontainer", "Comment": "v1.0.0-rc1-224-g5653ced", "Rev": "5653ced544b1fa9d9623f12aaf9601bf1aefc013" }, { "ImportPath": "github.com/opencontainers/runc/libcontainer/apparmor", "Comment": "v1.0.0-rc1-224-g5653ced", "Rev": "5653ced544b1fa9d9623f12aaf9601bf1aefc013" }, { "ImportPath": "github.com/opencontainers/runc/libcontainer/cgroups", "Comment": "v1.0.0-rc1-224-g5653ced", "Rev": "5653ced544b1fa9d9623f12aaf9601bf1aefc013" }, { "ImportPath": "github.com/opencontainers/runc/libcontainer/cgroups/fs", "Comment": "v1.0.0-rc1-224-g5653ced", "Rev": "5653ced544b1fa9d9623f12aaf9601bf1aefc013" }, { "ImportPath": "github.com/opencontainers/runc/libcontainer/cgroups/systemd", "Comment": "v1.0.0-rc1-224-g5653ced", "Rev": "5653ced544b1fa9d9623f12aaf9601bf1aefc013" }, { "ImportPath": "github.com/opencontainers/runc/libcontainer/configs", "Comment": "v1.0.0-rc1-224-g5653ced", "Rev": "5653ced544b1fa9d9623f12aaf9601bf1aefc013" }, { "ImportPath": "github.com/opencontainers/runc/libcontainer/configs/validate", "Comment": "v1.0.0-rc1-224-g5653ced", "Rev": "5653ced544b1fa9d9623f12aaf9601bf1aefc013" }, { "ImportPath": "github.com/opencontainers/runc/libcontainer/criurpc", "Comment": "v1.0.0-rc1-224-g5653ced", "Rev": "5653ced544b1fa9d9623f12aaf9601bf1aefc013" }, { "ImportPath": "github.com/opencontainers/runc/libcontainer/keys", "Comment": "v1.0.0-rc1-224-g5653ced", "Rev": "5653ced544b1fa9d9623f12aaf9601bf1aefc013" }, { "ImportPath": "github.com/opencontainers/runc/libcontainer/label", "Comment": "v1.0.0-rc1-224-g5653ced", "Rev": "5653ced544b1fa9d9623f12aaf9601bf1aefc013" }, { "ImportPath": "github.com/opencontainers/runc/libcontainer/seccomp", "Comment": "v1.0.0-rc1-224-g5653ced", "Rev": "5653ced544b1fa9d9623f12aaf9601bf1aefc013" }, { "ImportPath": "github.com/opencontainers/runc/libcontainer/selinux", "Comment": "v1.0.0-rc1-224-g5653ced", "Rev": "5653ced544b1fa9d9623f12aaf9601bf1aefc013" }, { "ImportPath": "github.com/opencontainers/runc/libcontainer/stacktrace", "Comment": "v1.0.0-rc1-224-g5653ced", "Rev": "5653ced544b1fa9d9623f12aaf9601bf1aefc013" }, { "ImportPath": "github.com/opencontainers/runc/libcontainer/system", "Comment": "v1.0.0-rc1-224-g5653ced", "Rev": "5653ced544b1fa9d9623f12aaf9601bf1aefc013" }, { "ImportPath": "github.com/opencontainers/runc/libcontainer/user", "Comment": "v1.0.0-rc1-224-g5653ced", "Rev": "5653ced544b1fa9d9623f12aaf9601bf1aefc013" }, { "ImportPath": "github.com/opencontainers/runc/libcontainer/utils", "Comment": "v1.0.0-rc1-224-g5653ced", "Rev": "5653ced544b1fa9d9623f12aaf9601bf1aefc013" }, { "ImportPath": "github.com/pborman/uuid", "Rev": "cccd189d45f7ac3368a0d127efb7f4d08ae0b655" }, { "ImportPath": "github.com/prometheus/client_golang/prometheus", "Comment": "0.7.0-52-ge51041b", "Rev": "e51041b3fa41cece0dca035740ba6411905be473" }, { "ImportPath": "github.com/prometheus/client_model/go", "Comment": "model-0.0.2-12-gfa8ad6f", "Rev": "fa8ad6fec33561be4280a8f0514318c79d7f6cb6" }, { "ImportPath": "github.com/prometheus/common/expfmt", "Rev": "1cc3e4c3b28fd42633a8c389c98cfbadf42621b1" }, { "ImportPath": "github.com/prometheus/common/model", "Rev": "1cc3e4c3b28fd42633a8c389c98cfbadf42621b1" }, { "ImportPath": "github.com/prometheus/procfs", "Rev": "6c34ef819e19b4e16f410100ace4aa006f0e3bf8" }, { "ImportPath": "github.com/seccomp/libseccomp-golang", "Rev": "1b506fc7c24eec5a3693cdcbed40d9c226cfc6a1" }, { "ImportPath": "github.com/stretchr/objx", "Rev": "cbeaeb16a013161a98496fad62933b1d21786672" }, { "ImportPath": "github.com/stretchr/testify/assert", "Rev": "8ce79b9f0b77745113f82c17d0756771456ccbd3" }, { "ImportPath": "github.com/stretchr/testify/mock", "Rev": "8ce79b9f0b77745113f82c17d0756771456ccbd3" }, { "ImportPath": "github.com/stretchr/testify/require", "Rev": "8ce79b9f0b77745113f82c17d0756771456ccbd3" }, { "ImportPath": "github.com/syndtr/gocapability/capability", "Rev": "2c00daeb6c3b45114c80ac44119e7b8801fdd852" }, { "ImportPath": "github.com/vishvananda/netlink", "Rev": "1e2e08e8a2dcdacaae3f14ac44c5cfa31361f270" }, { "ImportPath": "github.com/vishvananda/netlink/nl", "Rev": "1e2e08e8a2dcdacaae3f14ac44c5cfa31361f270" }, { "ImportPath": "golang.org/x/exp/inotify", "Rev": "292a51b8d262487dab23a588950e8052d63d9113" }, { "ImportPath": "golang.org/x/net/context", "Rev": "5627bad10b821d907ac4dc81fb3535ec7dd81c2b" }, { "ImportPath": "golang.org/x/net/context/ctxhttp", "Rev": "5627bad10b821d907ac4dc81fb3535ec7dd81c2b" }, { "ImportPath": "golang.org/x/net/http2", "Rev": "5627bad10b821d907ac4dc81fb3535ec7dd81c2b" }, { "ImportPath": "golang.org/x/net/http2/hpack", "Rev": "5627bad10b821d907ac4dc81fb3535ec7dd81c2b" }, { "ImportPath": "golang.org/x/net/internal/timeseries", "Rev": "5627bad10b821d907ac4dc81fb3535ec7dd81c2b" }, { "ImportPath": "golang.org/x/net/proxy", "Rev": "5627bad10b821d907ac4dc81fb3535ec7dd81c2b" }, { "ImportPath": "golang.org/x/net/trace", "Rev": "5627bad10b821d907ac4dc81fb3535ec7dd81c2b" }, { "ImportPath": "golang.org/x/oauth2", "Rev": "ca8a464d23d55afd32571475db223e065ffd8a52" }, { "ImportPath": "golang.org/x/oauth2/internal", "Rev": "ca8a464d23d55afd32571475db223e065ffd8a52" }, { "ImportPath": "golang.org/x/oauth2/jws", "Rev": "ca8a464d23d55afd32571475db223e065ffd8a52" }, { "ImportPath": "golang.org/x/oauth2/jwt", "Rev": "ca8a464d23d55afd32571475db223e065ffd8a52" }, { "ImportPath": "google.golang.org/api/bigquery/v2", "Rev": "0c2979aeaa5b573e60d3ddffe5ce8dca8df309bd" }, { "ImportPath": "google.golang.org/api/googleapi", "Rev": "0c2979aeaa5b573e60d3ddffe5ce8dca8df309bd" }, { "ImportPath": "google.golang.org/api/googleapi/internal/uritemplates", "Rev": "0c2979aeaa5b573e60d3ddffe5ce8dca8df309bd" }, { "ImportPath": "google.golang.org/grpc", "Rev": "3c4302b7131d2b14bb9c8aff7aa909bc20540145" }, { "ImportPath": "google.golang.org/grpc/codes", "Rev": "3c4302b7131d2b14bb9c8aff7aa909bc20540145" }, { "ImportPath": "google.golang.org/grpc/credentials", "Rev": "3c4302b7131d2b14bb9c8aff7aa909bc20540145" }, { "ImportPath": "google.golang.org/grpc/grpclog", "Rev": "3c4302b7131d2b14bb9c8aff7aa909bc20540145" }, { "ImportPath": "google.golang.org/grpc/metadata", "Rev": "3c4302b7131d2b14bb9c8aff7aa909bc20540145" }, { "ImportPath": "google.golang.org/grpc/naming", "Rev": "3c4302b7131d2b14bb9c8aff7aa909bc20540145" }, { "ImportPath": "google.golang.org/grpc/peer", "Rev": "3c4302b7131d2b14bb9c8aff7aa909bc20540145" }, { "ImportPath": "google.golang.org/grpc/transport", "Rev": "3c4302b7131d2b14bb9c8aff7aa909bc20540145" }, { "ImportPath": "gopkg.in/olivere/elastic.v2", "Comment": "v2.0.12", "Rev": "3cfe88295d20b6299bd935131fc0fd17316405ad" }, { "ImportPath": "gopkg.in/olivere/elastic.v2/uritemplates", "Comment": "v2.0.12", "Rev": "3cfe88295d20b6299bd935131fc0fd17316405ad" } ] } cadvisor-0.25.0/Godeps/Readme000066400000000000000000000002101306035727200157470ustar00rootroot00000000000000This directory tree is generated automatically by godep. Please do not edit. See https://github.com/tools/godep for more information. cadvisor-0.25.0/LICENSE000066400000000000000000000250151306035727200144250ustar00rootroot00000000000000 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 cadvisor-0.25.0/Makefile000066400000000000000000000026531306035727200150630ustar00rootroot00000000000000# Copyright 2015 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 GO := go pkgs = $(shell $(GO) list ./... | grep -v vendor) all: presubmit build test test: @echo ">> running tests" @$(GO) test -short -race $(pkgs) test-integration: @./build/integration.sh test-runner: @$(GO) build github.com/google/cadvisor/integration/runner format: @echo ">> formatting code" @$(GO) fmt $(pkgs) vet: @echo ">> vetting code" @$(GO) vet $(pkgs) build: assets @echo ">> building binaries" @./build/build.sh assets: @echo ">> building assets" @./build/assets.sh release: @echo ">> building release binaries" @./build/release.sh docker: @docker build -t cadvisor:$(shell git rev-parse --short HEAD) -f deploy/Dockerfile . presubmit: vet @echo ">> checking go formatting" @./build/check_gofmt.sh @echo ">> checking file boilerplate" @./build/check_boilerplate.sh .PHONY: all build docker format release test test-integration vet presubmit cadvisor-0.25.0/README.md000066400000000000000000000071461306035727200147040ustar00rootroot00000000000000# 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, histograms of complete historical resource usage and network statistics. This data is exported by container and machine-wide. cAdvisor has native support for [Docker](https://github.com/docker/docker) containers and should support just about any other container type out of the box. We strive for support across the board so feel free to open an issue if that is not the case. cAdvisor's container abstraction is based on [lmctfy](https://github.com/google/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, we have a Docker image that includes everything you need to get started. You can run a single cAdvisor to monitor the whole machine. Simply run: ``` sudo docker run \ --volume=/:/rootfs:ro \ --volume=/var/run:/var/run:rw \ --volume=/sys:/sys:ro \ --volume=/var/lib/docker/:/var/lib/docker:ro \ --publish=8080:8080 \ --detach=true \ --name=cadvisor \ google/cadvisor:latest ``` cAdvisor is now running (in the background) on `http://localhost:8080`. The setup includes directories with Docker state cAdvisor needs to observe. **Note**: If you're running on CentOS, Fedora, RHEL, or are using LXC take a look at our [running instructions](docs/running.md). We have detailed [instructions](docs/running.md#standalone) on running cAdvisor standalone outside of Docker. cAdvisor [running options](docs/runtime_options.md) may also be interesting for advanced usecases. If you want to build your own cAdvisor Docker image see our [deployment](docs/deploy.md) page. ## Building and Testing See the more detailed instructions in the [build page](docs/development/build.md). This includes instructions for building and deploying the cAdvisor Docker image. ## Exporting stats cAdvisor supports exporting stats to various storage plugins. See the [documentation](docs/storage/README.md) for more details and examples. ## Web UI cAdvisor exposes a web UI at its port: `http://:/` See the [documentation](docs/web.md) for more details. ## Remote REST API & Clients cAdvisor exposes its raw and processed stats via a versioned remote REST API. See the API's [documentation](docs/api.md) for more information. There is also an official Go client implementation in the [client](client/) directory. See the [documentation](docs/clients.md) for more information. ## 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 hang out on [Slack](https://kubernetes.slack.com) in the #sig-node channel (get an invitation [here](http://slack.kubernetes.io/)). We also have the [google-containers Google Groups mailing list](https://groups.google.com/forum/#!forum/google-containers). cadvisor-0.25.0/api/000077500000000000000000000000001306035727200141665ustar00rootroot00000000000000cadvisor-0.25.0/api/handler.go000066400000000000000000000154311306035727200161360ustar00rootroot00000000000000// 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 api provides a handler for /api/ package api import ( "encoding/json" "errors" "fmt" "io" "net/http" "path" "regexp" "sort" "strconv" "strings" "time" "github.com/google/cadvisor/events" httpmux "github.com/google/cadvisor/http/mux" info "github.com/google/cadvisor/info/v1" "github.com/google/cadvisor/manager" "github.com/golang/glog" ) const ( apiResource = "/api/" ) func RegisterHandlers(mux httpmux.Mux, m manager.Manager) error { apiVersions := getApiVersions() supportedApiVersions := make(map[string]ApiVersion, len(apiVersions)) for _, v := range apiVersions { supportedApiVersions[v.Version()] = v } mux.HandleFunc(apiResource, func(w http.ResponseWriter, r *http.Request) { err := handleRequest(supportedApiVersions, m, w, r) if err != nil { http.Error(w, err.Error(), 500) } }) return nil } // Captures the API version, requestType [optional], and remaining request [optional]. var apiRegexp = regexp.MustCompile(`/api/([^/]+)/?([^/]+)?(.*)`) const ( apiVersion = iota + 1 apiRequestType apiRequestArgs ) func handleRequest(supportedApiVersions map[string]ApiVersion, m manager.Manager, w http.ResponseWriter, r *http.Request) error { start := time.Now() defer func() { glog.V(4).Infof("Request took %s", time.Since(start)) }() request := r.URL.Path const apiPrefix = "/api" if !strings.HasPrefix(request, apiPrefix) { return fmt.Errorf("incomplete API request %q", request) } // If the request doesn't have an API version, list those. if request == apiPrefix || request == apiResource { versions := make([]string, 0, len(supportedApiVersions)) for v := range supportedApiVersions { versions = append(versions, v) } sort.Strings(versions) fmt.Fprintf(w, "Supported API versions: %s", strings.Join(versions, ",")) return nil } // Verify that we have all the elements we expect: // //[/] requestElements := apiRegexp.FindStringSubmatch(request) if len(requestElements) == 0 { return fmt.Errorf("malformed request %q", request) } version := requestElements[apiVersion] requestType := requestElements[apiRequestType] requestArgs := strings.Split(requestElements[apiRequestArgs], "/") // Check supported versions. versionHandler, ok := supportedApiVersions[version] if !ok { return fmt.Errorf("unsupported API version %q", version) } // If no request type, list possible request types. if requestType == "" { requestTypes := versionHandler.SupportedRequestTypes() sort.Strings(requestTypes) fmt.Fprintf(w, "Supported request types: %q", strings.Join(requestTypes, ",")) return nil } // Trim the first empty element from the request. if len(requestArgs) > 0 && requestArgs[0] == "" { requestArgs = requestArgs[1:] } return versionHandler.HandleRequest(requestType, requestArgs, m, w, r) } func writeResult(res interface{}, w http.ResponseWriter) error { out, err := json.Marshal(res) if err != nil { return fmt.Errorf("failed to marshall response %+v with error: %s", res, err) } w.Header().Set("Content-Type", "application/json") w.Write(out) return nil } func streamResults(eventChannel *events.EventChannel, w http.ResponseWriter, r *http.Request, m manager.Manager) error { cn, ok := w.(http.CloseNotifier) if !ok { return errors.New("could not access http.CloseNotifier") } flusher, ok := w.(http.Flusher) if !ok { return errors.New("could not access http.Flusher") } w.Header().Set("Transfer-Encoding", "chunked") w.WriteHeader(http.StatusOK) flusher.Flush() enc := json.NewEncoder(w) for { select { case <-cn.CloseNotify(): m.CloseEventChannel(eventChannel.GetWatchId()) return nil case ev := <-eventChannel.GetChannel(): err := enc.Encode(ev) if err != nil { glog.Errorf("error encoding message %+v for result stream: %v", ev, err) } flusher.Flush() } } } func getContainerInfoRequest(body io.ReadCloser) (*info.ContainerInfoRequest, error) { query := info.DefaultContainerInfoRequest() decoder := json.NewDecoder(body) err := decoder.Decode(&query) if err != nil && err != io.EOF { return nil, fmt.Errorf("unable to decode the json value: %s", err) } return &query, nil } // The user can set any or none of the following arguments in any order // with any twice defined arguments being assigned the first value. // If the value type for the argument is wrong the field will be assumed to be // unassigned // bools: stream, subcontainers, oom_events, creation_events, deletion_events // ints: max_events, start_time (unix timestamp), end_time (unix timestamp) // example r.URL: http://localhost:8080/api/v1.3/events?oom_events=true&stream=true func getEventRequest(r *http.Request) (*events.Request, bool, error) { query := events.NewRequest() stream := false urlMap := r.URL.Query() if val, ok := urlMap["stream"]; ok { newBool, err := strconv.ParseBool(val[0]) if err == nil { stream = newBool } } if val, ok := urlMap["subcontainers"]; ok { newBool, err := strconv.ParseBool(val[0]) if err == nil { query.IncludeSubcontainers = newBool } } eventTypes := map[string]info.EventType{ "oom_events": info.EventOom, "oom_kill_events": info.EventOomKill, "creation_events": info.EventContainerCreation, "deletion_events": info.EventContainerDeletion, } allEventTypes := false if val, ok := urlMap["all_events"]; ok { newBool, err := strconv.ParseBool(val[0]) if err == nil { allEventTypes = newBool } } for opt, eventType := range eventTypes { if allEventTypes { query.EventType[eventType] = true } else if val, ok := urlMap[opt]; ok { newBool, err := strconv.ParseBool(val[0]) if err == nil { query.EventType[eventType] = newBool } } } if val, ok := urlMap["max_events"]; ok { newInt, err := strconv.Atoi(val[0]) if err == nil { query.MaxEventsReturned = int(newInt) } } if val, ok := urlMap["start_time"]; ok { newTime, err := time.Parse(time.RFC3339, val[0]) if err == nil { query.StartTime = newTime } } if val, ok := urlMap["end_time"]; ok { newTime, err := time.Parse(time.RFC3339, val[0]) if err == nil { query.EndTime = newTime } } return query, stream, nil } func getContainerName(request []string) string { return path.Join("/", strings.Join(request, "/")) } cadvisor-0.25.0/api/versions.go000066400000000000000000000342761306035727200164010ustar00rootroot00000000000000// Copyright 2015 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 api import ( "fmt" "net/http" "path" "strconv" info "github.com/google/cadvisor/info/v1" "github.com/google/cadvisor/info/v2" "github.com/google/cadvisor/manager" "github.com/golang/glog" ) const ( containersApi = "containers" subcontainersApi = "subcontainers" machineApi = "machine" machineStatsApi = "machinestats" dockerApi = "docker" summaryApi = "summary" statsApi = "stats" specApi = "spec" eventsApi = "events" storageApi = "storage" attributesApi = "attributes" versionApi = "version" psApi = "ps" customMetricsApi = "appmetrics" ) // Interface for a cAdvisor API version type ApiVersion interface { // Returns the version string. Version() string // List of supported API endpoints. SupportedRequestTypes() []string // Handles a request. The second argument is the parameters after /api// HandleRequest(requestType string, request []string, m manager.Manager, w http.ResponseWriter, r *http.Request) error } // Gets all supported API versions. func getApiVersions() []ApiVersion { v1_0 := &version1_0{} v1_1 := newVersion1_1(v1_0) v1_2 := newVersion1_2(v1_1) v1_3 := newVersion1_3(v1_2) v2_0 := newVersion2_0() v2_1 := newVersion2_1(v2_0) return []ApiVersion{v1_0, v1_1, v1_2, v1_3, v2_0, v2_1} } // API v1.0 type version1_0 struct { } func (self *version1_0) Version() string { return "v1.0" } func (self *version1_0) SupportedRequestTypes() []string { return []string{containersApi, machineApi} } func (self *version1_0) HandleRequest(requestType string, request []string, m manager.Manager, w http.ResponseWriter, r *http.Request) error { switch requestType { case machineApi: glog.V(4).Infof("Api - Machine") // Get the MachineInfo machineInfo, err := m.GetMachineInfo() if err != nil { return err } err = writeResult(machineInfo, w) if err != nil { return err } case containersApi: containerName := getContainerName(request) glog.V(4).Infof("Api - Container(%s)", containerName) // Get the query request. query, err := getContainerInfoRequest(r.Body) if err != nil { return err } // Get the container. cont, err := m.GetContainerInfo(containerName, query) if err != nil { return fmt.Errorf("failed to get container %q with error: %s", containerName, err) } // Only output the container as JSON. err = writeResult(cont, w) if err != nil { return err } default: return fmt.Errorf("unknown request type %q", requestType) } return nil } // API v1.1 type version1_1 struct { baseVersion *version1_0 } // v1.1 builds on v1.0. func newVersion1_1(v *version1_0) *version1_1 { return &version1_1{ baseVersion: v, } } func (self *version1_1) Version() string { return "v1.1" } func (self *version1_1) SupportedRequestTypes() []string { return append(self.baseVersion.SupportedRequestTypes(), subcontainersApi) } func (self *version1_1) HandleRequest(requestType string, request []string, m manager.Manager, w http.ResponseWriter, r *http.Request) error { switch requestType { case subcontainersApi: containerName := getContainerName(request) glog.V(4).Infof("Api - Subcontainers(%s)", containerName) // Get the query request. query, err := getContainerInfoRequest(r.Body) if err != nil { return err } // Get the subcontainers. containers, err := m.SubcontainersInfo(containerName, query) if err != nil { return fmt.Errorf("failed to get subcontainers for container %q with error: %s", containerName, err) } // Only output the containers as JSON. err = writeResult(containers, w) if err != nil { return err } return nil default: return self.baseVersion.HandleRequest(requestType, request, m, w, r) } } // API v1.2 type version1_2 struct { baseVersion *version1_1 } // v1.2 builds on v1.1. func newVersion1_2(v *version1_1) *version1_2 { return &version1_2{ baseVersion: v, } } func (self *version1_2) Version() string { return "v1.2" } func (self *version1_2) SupportedRequestTypes() []string { return append(self.baseVersion.SupportedRequestTypes(), dockerApi) } func (self *version1_2) HandleRequest(requestType string, request []string, m manager.Manager, w http.ResponseWriter, r *http.Request) error { switch requestType { case dockerApi: glog.V(4).Infof("Api - Docker(%v)", request) // Get the query request. query, err := getContainerInfoRequest(r.Body) if err != nil { return err } var containers map[string]info.ContainerInfo // map requests for "docker/" to "docker" if len(request) == 1 && len(request[0]) == 0 { request = request[:0] } switch len(request) { case 0: // Get all Docker containers. containers, err = m.AllDockerContainers(query) if err != nil { return fmt.Errorf("failed to get all Docker containers with error: %v", err) } case 1: // Get one Docker container. var cont info.ContainerInfo cont, err = m.DockerContainer(request[0], query) if err != nil { return fmt.Errorf("failed to get Docker container %q with error: %v", request[0], err) } containers = map[string]info.ContainerInfo{ cont.Name: cont, } default: return fmt.Errorf("unknown request for Docker container %v", request) } // Only output the containers as JSON. err = writeResult(containers, w) if err != nil { return err } return nil default: return self.baseVersion.HandleRequest(requestType, request, m, w, r) } } // API v1.3 type version1_3 struct { baseVersion *version1_2 } // v1.3 builds on v1.2. func newVersion1_3(v *version1_2) *version1_3 { return &version1_3{ baseVersion: v, } } func (self *version1_3) Version() string { return "v1.3" } func (self *version1_3) SupportedRequestTypes() []string { return append(self.baseVersion.SupportedRequestTypes(), eventsApi) } func (self *version1_3) HandleRequest(requestType string, request []string, m manager.Manager, w http.ResponseWriter, r *http.Request) error { switch requestType { case eventsApi: return handleEventRequest(request, m, w, r) default: return self.baseVersion.HandleRequest(requestType, request, m, w, r) } } func handleEventRequest(request []string, m manager.Manager, w http.ResponseWriter, r *http.Request) error { query, stream, err := getEventRequest(r) if err != nil { return err } query.ContainerName = path.Join("/", getContainerName(request)) glog.V(4).Infof("Api - Events(%v)", query) if !stream { pastEvents, err := m.GetPastEvents(query) if err != nil { return err } return writeResult(pastEvents, w) } eventChannel, err := m.WatchForEvents(query) if err != nil { return err } return streamResults(eventChannel, w, r, m) } // API v2.0 type version2_0 struct { } func newVersion2_0() *version2_0 { return &version2_0{} } func (self *version2_0) Version() string { return "v2.0" } func (self *version2_0) SupportedRequestTypes() []string { return []string{versionApi, attributesApi, eventsApi, machineApi, summaryApi, statsApi, specApi, storageApi, psApi, customMetricsApi} } func (self *version2_0) HandleRequest(requestType string, request []string, m manager.Manager, w http.ResponseWriter, r *http.Request) error { opt, err := getRequestOptions(r) if err != nil { return err } switch requestType { case versionApi: glog.V(4).Infof("Api - Version") versionInfo, err := m.GetVersionInfo() if err != nil { return err } return writeResult(versionInfo.CadvisorVersion, w) case attributesApi: glog.V(4).Info("Api - Attributes") machineInfo, err := m.GetMachineInfo() if err != nil { return err } versionInfo, err := m.GetVersionInfo() if err != nil { return err } info := v2.GetAttributes(machineInfo, versionInfo) return writeResult(info, w) case machineApi: glog.V(4).Info("Api - Machine") // TODO(rjnagal): Move machineInfo from v1. machineInfo, err := m.GetMachineInfo() if err != nil { return err } return writeResult(machineInfo, w) case summaryApi: containerName := getContainerName(request) glog.V(4).Infof("Api - Summary for container %q, options %+v", containerName, opt) stats, err := m.GetDerivedStats(containerName, opt) if err != nil { return err } return writeResult(stats, w) case statsApi: name := getContainerName(request) glog.V(4).Infof("Api - Stats: Looking for stats for container %q, options %+v", name, opt) infos, err := m.GetRequestedContainersInfo(name, opt) if err != nil { if len(infos) == 0 { return err } glog.Errorf("Error calling GetRequestedContainersInfo: %v", err) } contStats := make(map[string][]v2.DeprecatedContainerStats, 0) for name, cinfo := range infos { contStats[name] = v2.DeprecatedStatsFromV1(cinfo) } return writeResult(contStats, w) case customMetricsApi: containerName := getContainerName(request) glog.V(4).Infof("Api - Custom Metrics: Looking for metrics for container %q, options %+v", containerName, opt) infos, err := m.GetContainerInfoV2(containerName, opt) if err != nil { return err } contMetrics := make(map[string]map[string]map[string][]info.MetricValBasic, 0) for _, cinfo := range infos { metrics := make(map[string]map[string][]info.MetricValBasic, 0) for _, contStat := range cinfo.Stats { if len(contStat.CustomMetrics) == 0 { continue } for name, allLabels := range contStat.CustomMetrics { metricLabels := make(map[string][]info.MetricValBasic, 0) for _, metric := range allLabels { if !metric.Timestamp.IsZero() { metVal := info.MetricValBasic{ Timestamp: metric.Timestamp, IntValue: metric.IntValue, FloatValue: metric.FloatValue, } labels := metrics[name] if labels != nil { values := labels[metric.Label] values = append(values, metVal) labels[metric.Label] = values metrics[name] = labels } else { metricLabels[metric.Label] = []info.MetricValBasic{metVal} metrics[name] = metricLabels } } } } } contMetrics[containerName] = metrics } return writeResult(contMetrics, w) case specApi: containerName := getContainerName(request) glog.V(4).Infof("Api - Spec for container %q, options %+v", containerName, opt) specs, err := m.GetContainerSpec(containerName, opt) if err != nil { return err } return writeResult(specs, w) case storageApi: var err error fi := []v2.FsInfo{} label := r.URL.Query().Get("label") if len(label) == 0 { // Get all global filesystems info. fi, err = m.GetFsInfo("") if err != nil { return err } } else { // Get a specific label. fi, err = m.GetFsInfo(label) if err != nil { return err } } return writeResult(fi, w) case eventsApi: return handleEventRequest(request, m, w, r) case psApi: // reuse container type from request. // ignore recursive. // TODO(rjnagal): consider count to limit ps output. name := getContainerName(request) glog.V(4).Infof("Api - Spec for container %q, options %+v", name, opt) ps, err := m.GetProcessList(name, opt) if err != nil { return fmt.Errorf("process listing failed: %v", err) } return writeResult(ps, w) default: return fmt.Errorf("unknown request type %q", requestType) } } type version2_1 struct { baseVersion *version2_0 } func newVersion2_1(v *version2_0) *version2_1 { return &version2_1{ baseVersion: v, } } func (self *version2_1) Version() string { return "v2.1" } func (self *version2_1) SupportedRequestTypes() []string { return append([]string{machineStatsApi}, self.baseVersion.SupportedRequestTypes()...) } func (self *version2_1) HandleRequest(requestType string, request []string, m manager.Manager, w http.ResponseWriter, r *http.Request) error { // Get the query request. opt, err := getRequestOptions(r) if err != nil { return err } switch requestType { case machineStatsApi: glog.V(4).Infof("Api - MachineStats(%v)", request) cont, err := m.GetRequestedContainersInfo("/", opt) if err != nil { if len(cont) == 0 { return err } glog.Errorf("Error calling GetRequestedContainersInfo: %v", err) } return writeResult(v2.MachineStatsFromV1(cont["/"]), w) case statsApi: name := getContainerName(request) glog.V(4).Infof("Api - Stats: Looking for stats for container %q, options %+v", name, opt) conts, err := m.GetRequestedContainersInfo(name, opt) if err != nil { if len(conts) == 0 { return err } glog.Errorf("Error calling GetRequestedContainersInfo: %v", err) } contStats := make(map[string]v2.ContainerInfo, len(conts)) for name, cont := range conts { if name == "/" { // Root cgroup stats should be exposed as machine stats continue } contStats[name] = v2.ContainerInfo{ Spec: v2.ContainerSpecFromV1(&cont.Spec, cont.Aliases, cont.Namespace), Stats: v2.ContainerStatsFromV1(name, &cont.Spec, cont.Stats), } } return writeResult(contStats, w) default: return self.baseVersion.HandleRequest(requestType, request, m, w, r) } } func getRequestOptions(r *http.Request) (v2.RequestOptions, error) { supportedTypes := map[string]bool{ v2.TypeName: true, v2.TypeDocker: true, } // fill in the defaults. opt := v2.RequestOptions{ IdType: v2.TypeName, Count: 64, Recursive: false, } idType := r.URL.Query().Get("type") if len(idType) != 0 { if !supportedTypes[idType] { return opt, fmt.Errorf("unknown 'type' %q", idType) } opt.IdType = idType } count := r.URL.Query().Get("count") if len(count) != 0 { n, err := strconv.ParseUint(count, 10, 32) if err != nil { return opt, fmt.Errorf("failed to parse 'count' option: %v", count) } opt.Count = int(n) } recursive := r.URL.Query().Get("recursive") if recursive == "true" { opt.Recursive = true } return opt, nil } cadvisor-0.25.0/api/versions_test.go000066400000000000000000000046271306035727200174350ustar00rootroot00000000000000// Copyright 2015 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 api import ( "io" "net/http" "reflect" "testing" "github.com/google/cadvisor/events" info "github.com/google/cadvisor/info/v1" "github.com/stretchr/testify/assert" ) // returns an http.Request pointer for an input url test string func makeHTTPRequest(requestURL string, t *testing.T) *http.Request { dummyReader, _ := io.Pipe() r, err := http.NewRequest("GET", requestURL, dummyReader) assert.Nil(t, err) return r } func TestGetEventRequestBasicRequest(t *testing.T) { r := makeHTTPRequest("http://localhost:8080/api/v1.3/events?oom_events=true&stream=false&max_events=20", t) expectedQuery := events.NewRequest() expectedQuery.EventType = map[info.EventType]bool{ info.EventOom: true, } expectedQuery.MaxEventsReturned = 20 receivedQuery, stream, err := getEventRequest(r) if !reflect.DeepEqual(expectedQuery, receivedQuery) { t.Errorf("expected %#v but received %#v", expectedQuery, receivedQuery) } assert.False(t, stream) assert.Nil(t, err) } func TestGetEventEmptyRequest(t *testing.T) { r := makeHTTPRequest("", t) expectedQuery := events.NewRequest() receivedQuery, stream, err := getEventRequest(r) if !reflect.DeepEqual(expectedQuery, receivedQuery) { t.Errorf("expected %#v but received %#v", expectedQuery, receivedQuery) } assert.False(t, stream) assert.Nil(t, err) } func TestGetEventRequestDoubleArgument(t *testing.T) { r := makeHTTPRequest("http://localhost:8080/api/v1.3/events?stream=true&oom_events=true&oom_events=false", t) expectedQuery := events.NewRequest() expectedQuery.EventType = map[info.EventType]bool{ info.EventOom: true, } receivedQuery, stream, err := getEventRequest(r) if !reflect.DeepEqual(expectedQuery, receivedQuery) { t.Errorf("expected %#v but received %#v", expectedQuery, receivedQuery) } assert.True(t, stream) assert.Nil(t, err) } cadvisor-0.25.0/build/000077500000000000000000000000001306035727200145145ustar00rootroot00000000000000cadvisor-0.25.0/build/assets.sh000077500000000000000000000040371306035727200163610ustar00rootroot00000000000000#!/bin/bash # Copyright 2015 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. set -e GIT_ROOT=$(dirname "${BASH_SOURCE}")/.. ASSETS_INPUT_DIRS="$GIT_ROOT/pages/assets/js/... $GIT_ROOT/pages/assets/styles/..." ASSETS_OUTPUT_PATH="$GIT_ROOT/pages/static/assets.go" ASSETS_PACKAGE="static" TEMPLATES_INPUT_DIRS="$GIT_ROOT/pages/assets/html/..." TEMPLATES_OUTPUT_PATH="$GIT_ROOT/pages/templates.go" TEMPLATES_PACKAGE="pages" FORCE="${FORCE:-}" # Force assets to be rebuilt if FORCE=true go get -u github.com/jteeuwen/go-bindata/... build_asset () { local package=$1 local output_path=$2 local input_dirs=${@:3} local tmp_output=$(mktemp) local year=$(date +%Y) go-bindata -nometadata -o $output_path -pkg $package $input_dirs cat build/boilerplate/boilerplate.go.txt | sed "s/YEAR/$year/" > "${tmp_output}" echo -e "// generated by build/assets.sh; DO NOT EDIT\n" >> "${tmp_output}" cat "${output_path}" >> "${tmp_output}" gofmt -w -s "${tmp_output}" mv "${tmp_output}" "${output_path}" } for f in $GIT_ROOT/pages/assets/js/* $GIT_ROOT/pages/assets/styles/*; do if [ "$FORCE" == "true" ] || [ "$f" -nt $ASSETS_OUTPUT_PATH -o ! -e $ASSETS_OUTPUT_PATH ]; then build_asset "$ASSETS_PACKAGE" "$ASSETS_OUTPUT_PATH" "$ASSETS_INPUT_DIRS" break; fi done for f in $GIT_ROOT/pages/assets/html/*; do if [ "$FORCE" == "true" ] || [ "$f" -nt $TEMPLATES_OUTPUT_PATH -o ! -e $TEMPLATES_OUTPUT_PATH ]; then build_asset "$TEMPLATES_PACKAGE" "$TEMPLATES_OUTPUT_PATH" "$TEMPLATES_INPUT_DIRS" break; fi done exit 0 cadvisor-0.25.0/build/boilerplate/000077500000000000000000000000001306035727200170165ustar00rootroot00000000000000cadvisor-0.25.0/build/boilerplate/boilerplate.go.txt000066400000000000000000000011411306035727200224620ustar00rootroot00000000000000// Copyright YEAR 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. cadvisor-0.25.0/build/boilerplate/boilerplate.py000077500000000000000000000112541306035727200217000ustar00rootroot00000000000000#!/usr/bin/env python # Copyright 2016 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from __future__ import print_function import argparse import glob import json import mmap import os import re import sys parser = argparse.ArgumentParser() parser.add_argument("filenames", help="list of files to check, all files if unspecified", nargs='*') args = parser.parse_args() rootdir = os.path.dirname(__file__) + "/../../" rootdir = os.path.abspath(rootdir) def get_refs(): refs = {} for path in glob.glob(os.path.join(rootdir, "build/boilerplate/boilerplate.*.txt")): extension = os.path.basename(path).split(".")[1] ref_file = open(path, 'r') ref = ref_file.read().splitlines() ref_file.close() refs[extension] = ref return refs def file_passes(filename, refs, regexs): try: f = open(filename, 'r') except: return False data = f.read() f.close() extension = file_extension(filename) ref = refs[extension] # remove build tags from the top of Go files if extension == "go": p = regexs["go_build_constraints"] (data, found) = p.subn("", data, 1) # remove shebang from the top of shell files if extension == "sh": p = regexs["shebang"] (data, found) = p.subn("", data, 1) data = data.splitlines() # if our test file is smaller than the reference it surely fails! if len(ref) > len(data): return False # trim our file to the same number of lines as the reference file data = data[:len(ref)] p = regexs["year"] for d in data: if p.search(d): return False # Replace all occurrences of the regex "2016|2015|2014" with "YEAR" p = regexs["date"] for i, d in enumerate(data): (data[i], found) = p.subn('YEAR', d) if found != 0: break # if we don't match the reference at this point, fail if ref != data: return False return True def file_extension(filename): return os.path.splitext(filename)[1].split(".")[-1].lower() skipped_dirs = ['Godeps', 'vendor', 'third_party', '_gopath', '_output', '.git'] def normalize_files(files): newfiles = [] for pathname in files: if any(x in pathname for x in skipped_dirs): continue newfiles.append(pathname) for i, pathname in enumerate(newfiles): if not os.path.isabs(pathname): newfiles[i] = os.path.join(rootdir, pathname) return newfiles def get_files(extensions): files = [] if len(args.filenames) > 0: files = args.filenames else: for root, dirs, walkfiles in os.walk(rootdir): # don't visit certain dirs. This is just a performance improvement # as we would prune these later in normalize_files(). But doing it # cuts down the amount of filesystem walking we do and cuts down # the size of the file list for d in skipped_dirs: if d in dirs: dirs.remove(d) for name in walkfiles: pathname = os.path.join(root, name) files.append(pathname) files = normalize_files(files) outfiles = [] for pathname in files: extension = file_extension(pathname) if extension in extensions: outfiles.append(pathname) return outfiles def get_regexs(): regexs = {} # Search for "YEAR" which exists in the boilerplate, but shouldn't in the real thing regexs["year"] = re.compile( 'YEAR' ) # dates can be 2014, 2015 or 2016, company holder names can be anything regexs["date"] = re.compile( '(2014|2015|2016|2017|2018|2019|2020)' ) # strip // +build \n\n build constraints regexs["go_build_constraints"] = re.compile(r"^(// \+build.*\n)+\n", re.MULTILINE) # strip #!.* from shell scripts regexs["shebang"] = re.compile(r"^(#!.*\n)\n*", re.MULTILINE) return regexs def main(): regexs = get_regexs() refs = get_refs() filenames = get_files(refs.keys()) for filename in filenames: if not file_passes(filename, refs, regexs): print(filename, file=sys.stdout) if __name__ == "__main__": sys.exit(main()) cadvisor-0.25.0/build/boilerplate/boilerplate.py.txt000066400000000000000000000011531306035727200225100ustar00rootroot00000000000000#!/usr/bin/env python # Copyright YEAR 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. cadvisor-0.25.0/build/boilerplate/boilerplate.sh.txt000066400000000000000000000011241306035727200224700ustar00rootroot00000000000000# Copyright YEAR 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. cadvisor-0.25.0/build/build.sh000077500000000000000000000035721306035727200161610ustar00rootroot00000000000000#!/usr/bin/env bash # Copyright 2015 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. set -e GO_FLAGS=${GO_FLAGS:-} # Extra go flags to use in the build. GO_CMD=${GO_CMD:-"install"} BUILD_USER=${BUILD_USER:-"${USER}@${HOSTNAME}"} BUILD_DATE=${BUILD_DATE:-$( date +%Y%m%d-%H:%M:%S )} VERBOSE=${VERBOSE:-} repo_path="github.com/google/cadvisor" version=$( git describe --tags --dirty --abbrev=14 | sed -E 's/-([0-9]+)-g/.\1+/' ) revision=$( git rev-parse --short HEAD 2> /dev/null || echo 'unknown' ) branch=$( git rev-parse --abbrev-ref HEAD 2> /dev/null || echo 'unknown' ) go_version=$( go version | sed -e 's/^[^0-9.]*\([0-9.]*\).*/\1/' ) # go 1.4 requires ldflags format to be "-X key value", not "-X key=value" ldseparator="=" if [ "${go_version:0:3}" = "1.4" ]; then ldseparator=" " fi ldflags=" -extldflags '-static' -X ${repo_path}/version.Version${ldseparator}${version} -X ${repo_path}/version.Revision${ldseparator}${revision} -X ${repo_path}/version.Branch${ldseparator}${branch} -X ${repo_path}/version.BuildUser${ldseparator}${BUILD_USER} -X ${repo_path}/version.BuildDate${ldseparator}${BUILD_DATE} -X ${repo_path}/version.GoVersion${ldseparator}${go_version}" echo ">> building cadvisor" if [ -n "$VERBOSE" ]; then echo "Building with -ldflags $ldflags" fi GOBIN=$PWD go "$GO_CMD" ${GO_FLAGS} -ldflags "${ldflags}" "${repo_path}" exit 0 cadvisor-0.25.0/build/check_boilerplate.sh000077500000000000000000000017101306035727200205110ustar00rootroot00000000000000#!/bin/bash # Copyright 2015 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. set -o errexit set -o nounset set -o pipefail GIT_ROOT=$(dirname "${BASH_SOURCE}")/.. boiler="${GIT_ROOT}/build/boilerplate/boilerplate.py" files_need_boilerplate=($(${boiler} "$@")) if [[ ${#files_need_boilerplate[@]} -gt 0 ]]; then for file in "${files_need_boilerplate[@]}"; do echo "Boilerplate header is wrong for: ${file}" done exit 1 fi cadvisor-0.25.0/build/check_errorf.sh000077500000000000000000000015441306035727200175130ustar00rootroot00000000000000#!/bin/bash # Copyright 2015 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. GO_FILES=$(find . -not -wholename "*Godeps*" -not -wholename "*vendor*" -name "*.go") for FILE in ${GO_FILES}; do ERRS=`grep 'fmt.Errorf("[A-Z]' ${FILE}` if [ $? -eq 0 ] then echo Incorrect error format in file ${FILE}: $ERRS exit 1 fi done exit 0 cadvisor-0.25.0/build/check_gofmt.sh000077500000000000000000000017071306035727200173310ustar00rootroot00000000000000#!/bin/bash # Copyright 2015 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. # Check formatting on non Godep'd code. GOFMT_PATHS=$(find . -not -wholename "*.git*" -not -wholename "*Godeps*" -not -wholename "*vendor*" -not -name "." -type d) # Find any files with gofmt problems BAD_FILES=$(gofmt -s -l $GOFMT_PATHS) if [ -n "$BAD_FILES" ]; then echo "The following files are not properly formatted:" echo $BAD_FILES exit 1 fi cadvisor-0.25.0/build/integration.sh000077500000000000000000000034221306035727200173770ustar00rootroot00000000000000#!/usr/bin/env bash # Copyright 2016 Google Inc. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. if [[ -n "${JENKINS_HOME}" ]]; then exec ./build/jenkins_e2e.sh fi set -e # Build the test binary. GO_FLAGS="-race" ./build/build.sh TEST_PID=$$ sudo printf "" # Refresh sudo credentials if necessary. function start { set +e # We want to handle errors if cAdvisor crashes. echo ">> starting cAdvisor locally" GORACE="halt_on_error=1" sudo -E ./cadvisor --docker_env_metadata_whitelist=TEST_VAR if [ $? != 0 ]; then echo "!! cAdvisor exited unexpectedly with Exit $?" kill $TEST_PID # cAdvisor crashed: abort testing. fi } start & RUNNER_PID=$! function cleanup { if pgrep cadvisor > /dev/null; then echo ">> stopping cAdvisor" sudo pkill -SIGINT cadvisor wait $RUNNER_PID fi } trap cleanup EXIT readonly TIMEOUT=30 # Timeout to wait for cAdvisor, in seconds. START=$(date +%s) while [ "$(curl -Gs http://localhost:8080/healthz)" != "ok" ]; do if (( $(date +%s) - $START > $TIMEOUT )); then echo "Timed out waiting for cAdvisor to start" exit 1 fi echo "Waiting for cAdvisor to start ..." sleep 1 done echo ">> running integration tests against local cAdvisor" go test github.com/google/cadvisor/integration/tests/... --vmodule=*=2 cadvisor-0.25.0/build/jenkins_e2e.sh000077500000000000000000000042521306035727200172520ustar00rootroot00000000000000#!/usr/bin/env bash # Copyright 2016 Google Inc. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. set -e set -x BUILDER=${BUILDER:-false} # Whether this is running a PR builder job. export GO_FLAGS="-race" export GORACE="halt_on_error=1" # Check whether assets need to be rebuilt. FORCE=true build/assets.sh if [[ ! -z "$(git diff --name-only pages)" ]]; then echo "Found changes to UI assets:" git diff --name-only pages echo "Run: `make assets FORCE=true`" exit 1 fi # Build & test with go 1.7 docker run --rm \ -w "/go/src/github.com/google/cadvisor" \ -v "${GOPATH}/src/github.com/google/cadvisor:/go/src/github.com/google/cadvisor" \ golang:1.7 make all test-runner # Nodes that are currently stable. When tests fail on a specific node, and the failure is not remedied within a week, that node will be removed from this list. golden_nodes=( e2e-cadvisor-ubuntu-trusty e2e-cadvisor-container-vm-v20151215 e2e-cadvisor-container-vm-v20160127 e2e-cadvisor-rhel-7 ) # TODO: Add test on GCI # TODO: Add test for kubernetes default image # e2e-cadvisor-container-vm-v20160321 # TODO: Temporarily disabled for #1344 # e2e-cadvisor-coreos-beta # TODO: enable when docker 1.10 is working # e2e-cadvisor-ubuntu-trusty-docker110 # TODO: Always fails with "Network tx and rx bytes should not be equal" # e2e-cadvisor-centos-v7 max_retries=8 ./runner --logtostderr --test-retry-count=$max_retries \ --test-retry-whitelist=integration/runner/retrywhitelist.txt \ --ssh-options "-i /var/lib/jenkins/gce_keys/google_compute_engine -o UserKnownHostsFile=/dev/null -o IdentitiesOnly=yes -o CheckHostIP=no -o StrictHostKeyChecking=no" \ ${golden_nodes[*]} cadvisor-0.25.0/build/release.sh000077500000000000000000000033221306035727200164730ustar00rootroot00000000000000#!/usr/bin/env bash # Copyright 2015 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. set -e VERSION=$( git describe --tags --dirty --abbrev=14 | sed -E 's/-([0-9]+)-g/.\1+/' ) # Only allow releases of tagged versions. TAGGED='^v[0-9]+\.[0-9]+\.[0-9]+(-(alpha|beta)[0-9]*)?$' if [[ ! "$VERSION" =~ $TAGGED ]]; then echo "Error: Only tagged versions are allowed for releases" >&2 echo "Found: $VERSION" >&2 exit 1 fi # Don't include hostname with release builds if ! git_user="$(git config --get user.email)"; then echo "Error: git user not set, use:" echo "git config user.email " exit 1 fi # Build the release. export BUILD_USER="$git_user" export BUILD_DATE=$( date +%Y%m%d ) # Release date is only to day-granularity export GO_CMD="build" # Don't use cached build objects for releases. export VERBOSE=true build/build.sh # Build the docker image echo ">> building cadvisor docker image" docker_tag="google/cadvisor:$VERSION" gcr_tag="gcr.io/google_containers/cadvisor:$VERSION" docker build -t $docker_tag -t $gcr_tag -f deploy/Dockerfile . echo echo "Release info:" echo "VERSION=$VERSION" sha256sum --tag cadvisor echo "docker image: $docker_tag" echo "gcr.io image: $gcr_tag" exit 0 cadvisor-0.25.0/cache/000077500000000000000000000000001306035727200144605ustar00rootroot00000000000000cadvisor-0.25.0/cache/cache.go000066400000000000000000000030021306035727200160450ustar00rootroot00000000000000// Copyright 2015 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 cache import info "github.com/google/cadvisor/info/v1" type Cache interface { // Add a ContainerStats for the specified container. AddStats(ref info.ContainerReference, stats *info.ContainerStats) error // Remove all cached information for the specified container. RemoveContainer(containerName string) 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. The // returned stats should be sorted in time increasing order, i.e. Most // recent stats should be the last. RecentStats(containerName string, numStats int) ([]*info.ContainerStats, 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 } cadvisor-0.25.0/cache/memory/000077500000000000000000000000001306035727200157705ustar00rootroot00000000000000cadvisor-0.25.0/cache/memory/memory.go000066400000000000000000000073421306035727200176350ustar00rootroot00000000000000// Copyright 2014 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package memory import ( "fmt" "sync" "time" info "github.com/google/cadvisor/info/v1" "github.com/google/cadvisor/storage" "github.com/google/cadvisor/utils" "github.com/golang/glog" ) // TODO(vmarmol): See about refactoring this class, we have an unecessary redirection of containerCache and InMemoryCache. // containerCache is used to store per-container information type containerCache struct { ref info.ContainerReference recentStats *utils.TimedStore maxAge time.Duration lock sync.RWMutex } func (self *containerCache) AddStats(stats *info.ContainerStats) error { self.lock.Lock() defer self.lock.Unlock() // Add the stat to storage. self.recentStats.Add(stats.Timestamp, stats) return nil } func (self *containerCache) RecentStats(start, end time.Time, maxStats int) ([]*info.ContainerStats, error) { self.lock.RLock() defer self.lock.RUnlock() result := self.recentStats.InTimeRange(start, end, maxStats) converted := make([]*info.ContainerStats, len(result)) for i, el := range result { converted[i] = el.(*info.ContainerStats) } return converted, nil } func newContainerStore(ref info.ContainerReference, maxAge time.Duration) *containerCache { return &containerCache{ ref: ref, recentStats: utils.NewTimedStore(maxAge, -1), maxAge: maxAge, } } type InMemoryCache struct { lock sync.RWMutex containerCacheMap map[string]*containerCache maxAge time.Duration backend storage.StorageDriver } func (self *InMemoryCache) AddStats(ref info.ContainerReference, stats *info.ContainerStats) error { var cstore *containerCache var ok bool func() { self.lock.Lock() defer self.lock.Unlock() if cstore, ok = self.containerCacheMap[ref.Name]; !ok { cstore = newContainerStore(ref, self.maxAge) self.containerCacheMap[ref.Name] = cstore } }() if self.backend != nil { // TODO(monnand): To deal with long delay write operations, we // may want to start a pool of goroutines to do write // operations. if err := self.backend.AddStats(ref, stats); err != nil { glog.Error(err) } } return cstore.AddStats(stats) } func (self *InMemoryCache) RecentStats(name string, start, end time.Time, maxStats int) ([]*info.ContainerStats, error) { var cstore *containerCache var ok bool err := func() error { self.lock.RLock() defer self.lock.RUnlock() if cstore, ok = self.containerCacheMap[name]; !ok { return fmt.Errorf("unable to find data for container %v", name) } return nil }() if err != nil { return nil, err } return cstore.RecentStats(start, end, maxStats) } func (self *InMemoryCache) Close() error { self.lock.Lock() self.containerCacheMap = make(map[string]*containerCache, 32) self.lock.Unlock() return nil } func (self *InMemoryCache) RemoveContainer(containerName string) error { self.lock.Lock() delete(self.containerCacheMap, containerName) self.lock.Unlock() return nil } func New( maxAge time.Duration, backend storage.StorageDriver, ) *InMemoryCache { ret := &InMemoryCache{ containerCacheMap: make(map[string]*containerCache, 32), maxAge: maxAge, backend: backend, } return ret } cadvisor-0.25.0/cache/memory/memory_test.go000066400000000000000000000052541306035727200206740ustar00rootroot00000000000000// 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" "time" info "github.com/google/cadvisor/info/v1" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) const containerName = "/container" var ( containerRef = info.ContainerReference{Name: containerName} zero time.Time ) // Make stats with the specified identifier. func makeStat(i int) *info.ContainerStats { return &info.ContainerStats{ Timestamp: zero.Add(time.Duration(i) * time.Second), Cpu: info.CpuStats{ LoadAverage: int32(i), }, } } func getRecentStats(t *testing.T, memoryCache *InMemoryCache, numStats int) []*info.ContainerStats { stats, err := memoryCache.RecentStats(containerName, zero, zero, numStats) require.Nil(t, err) return stats } func TestAddStats(t *testing.T) { memoryCache := New(60*time.Second, nil) assert := assert.New(t) assert.Nil(memoryCache.AddStats(containerRef, makeStat(0))) assert.Nil(memoryCache.AddStats(containerRef, makeStat(1))) assert.Nil(memoryCache.AddStats(containerRef, makeStat(2))) assert.Nil(memoryCache.AddStats(containerRef, makeStat(0))) containerRef2 := info.ContainerReference{ Name: "/container2", } assert.Nil(memoryCache.AddStats(containerRef2, makeStat(0))) assert.Nil(memoryCache.AddStats(containerRef2, makeStat(1))) } func TestRecentStatsNoRecentStats(t *testing.T) { memoryCache := makeWithStats(0) _, err := memoryCache.RecentStats(containerName, zero, zero, 60) assert.NotNil(t, err) } // Make an instance of InMemoryCache with n stats. func makeWithStats(n int) *InMemoryCache { memoryCache := New(60*time.Second, nil) for i := 0; i < n; i++ { memoryCache.AddStats(containerRef, makeStat(i)) } return memoryCache } func TestRecentStatsGetZeroStats(t *testing.T) { memoryCache := makeWithStats(10) assert.Len(t, getRecentStats(t, memoryCache, 0), 0) } func TestRecentStatsGetSomeStats(t *testing.T) { memoryCache := makeWithStats(10) assert.Len(t, getRecentStats(t, memoryCache, 5), 5) } func TestRecentStatsGetAllStats(t *testing.T) { memoryCache := makeWithStats(10) assert.Len(t, getRecentStats(t, memoryCache, -1), 10) } cadvisor-0.25.0/cadvisor.go000066400000000000000000000160051306035727200155600ustar00rootroot00000000000000// 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" "net/http" "net/http/pprof" "os" "os/signal" "runtime" "strings" "syscall" "time" "github.com/google/cadvisor/container" cadvisorhttp "github.com/google/cadvisor/http" "github.com/google/cadvisor/manager" "github.com/google/cadvisor/utils/sysfs" "github.com/google/cadvisor/version" "crypto/tls" "github.com/golang/glog" ) var argIp = flag.String("listen_ip", "", "IP to listen on, defaults to all IPs") var argPort = flag.Int("port", 8080, "port to listen") var maxProcs = flag.Int("max_procs", 0, "max number of CPUs that can be used simultaneously. Less than 1 for default (number of cores).") var versionFlag = flag.Bool("version", false, "print cAdvisor version and exit") var httpAuthFile = flag.String("http_auth_file", "", "HTTP auth file for the web UI") var httpAuthRealm = flag.String("http_auth_realm", "localhost", "HTTP auth realm for the web UI") var httpDigestFile = flag.String("http_digest_file", "", "HTTP digest file for the web UI") var httpDigestRealm = flag.String("http_digest_realm", "localhost", "HTTP digest file for the web UI") var prometheusEndpoint = flag.String("prometheus_endpoint", "/metrics", "Endpoint to expose Prometheus metrics on") var maxHousekeepingInterval = flag.Duration("max_housekeeping_interval", 60*time.Second, "Largest interval to allow between container housekeepings") var allowDynamicHousekeeping = flag.Bool("allow_dynamic_housekeeping", true, "Whether to allow the housekeeping interval to be dynamic") var enableProfiling = flag.Bool("profiling", false, "Enable profiling via web interface host:port/debug/pprof/") var collectorCert = flag.String("collector_cert", "", "Collector's certificate, exposed to endpoints for certificate based authentication.") var collectorKey = flag.String("collector_key", "", "Key for the collector's certificate") var ( // Metrics to be ignored. // Tcp metrics are ignored by default. ignoreMetrics metricSetValue = metricSetValue{container.MetricSet{container.NetworkTcpUsageMetrics: struct{}{}}} // List of metrics that can be ignored. ignoreWhitelist = container.MetricSet{ container.DiskUsageMetrics: struct{}{}, container.NetworkUsageMetrics: struct{}{}, container.NetworkTcpUsageMetrics: struct{}{}, } ) type metricSetValue struct { container.MetricSet } func (ml *metricSetValue) String() string { var values []string for metric, _ := range ml.MetricSet { values = append(values, string(metric)) } return strings.Join(values, ",") } func (ml *metricSetValue) Set(value string) error { ml.MetricSet = container.MetricSet{} if value == "" { return nil } for _, metric := range strings.Split(value, ",") { if ignoreWhitelist.Has(container.MetricKind(metric)) { (*ml).Add(container.MetricKind(metric)) } else { return fmt.Errorf("unsupported metric %q specified in disable_metrics", metric) } } return nil } func init() { flag.Var(&ignoreMetrics, "disable_metrics", "comma-separated list of `metrics` to be disabled. Options are 'disk', 'network', 'tcp'. Note: tcp is disabled by default due to high CPU usage.") } func main() { defer glog.Flush() flag.Parse() if *versionFlag { fmt.Printf("cAdvisor version %s (%s)\n", version.Info["version"], version.Info["revision"]) os.Exit(0) } setMaxProcs() memoryStorage, err := NewMemoryStorage() if err != nil { glog.Fatalf("Failed to initialize storage driver: %s", err) } sysFs, err := sysfs.NewRealSysFs() if err != nil { glog.Fatalf("Failed to create a system interface: %s", err) } collectorHttpClient := createCollectorHttpClient(*collectorCert, *collectorKey) containerManager, err := manager.New(memoryStorage, sysFs, *maxHousekeepingInterval, *allowDynamicHousekeeping, ignoreMetrics.MetricSet, &collectorHttpClient) if err != nil { glog.Fatalf("Failed to create a Container Manager: %s", err) } mux := http.NewServeMux() if *enableProfiling { mux.HandleFunc("/debug/pprof/", pprof.Index) mux.HandleFunc("/debug/pprof/cmdline", pprof.Cmdline) mux.HandleFunc("/debug/pprof/profile", pprof.Profile) mux.HandleFunc("/debug/pprof/symbol", pprof.Symbol) } // Register all HTTP handlers. err = cadvisorhttp.RegisterHandlers(mux, containerManager, *httpAuthFile, *httpAuthRealm, *httpDigestFile, *httpDigestRealm) if err != nil { glog.Fatalf("Failed to register HTTP handlers: %v", err) } cadvisorhttp.RegisterPrometheusHandler(mux, containerManager, *prometheusEndpoint, nil) // Start the manager. if err := containerManager.Start(); err != nil { glog.Fatalf("Failed to start container manager: %v", err) } // Install signal handler. installSignalHandler(containerManager) glog.Infof("Starting cAdvisor version: %s-%s on port %d", version.Info["version"], version.Info["revision"], *argPort) addr := fmt.Sprintf("%s:%d", *argIp, *argPort) glog.Fatal(http.ListenAndServe(addr, mux)) } func setMaxProcs() { // TODO(vmarmol): Consider limiting if we have a CPU mask in effect. // Allow as many threads as we have cores unless the user specified a value. var numProcs int if *maxProcs < 1 { numProcs = runtime.NumCPU() } else { numProcs = *maxProcs } runtime.GOMAXPROCS(numProcs) // Check if the setting was successful. actualNumProcs := runtime.GOMAXPROCS(0) if actualNumProcs != numProcs { glog.Warningf("Specified max procs of %v but using %v", numProcs, actualNumProcs) } } func installSignalHandler(containerManager manager.Manager) { c := make(chan os.Signal, 1) signal.Notify(c, os.Interrupt, os.Kill, syscall.SIGTERM) // Block until a signal is received. go func() { sig := <-c if err := containerManager.Stop(); err != nil { glog.Errorf("Failed to stop container manager: %v", err) } glog.Infof("Exiting given signal: %v", sig) os.Exit(0) }() } func createCollectorHttpClient(collectorCert, collectorKey string) http.Client { //Enable accessing insecure endpoints. We should be able to access metrics from any endpoint tlsConfig := &tls.Config{ InsecureSkipVerify: true, } if collectorCert != "" { if collectorKey == "" { glog.Fatal("The collector_key value must be specified if the collector_cert value is set.") } cert, err := tls.LoadX509KeyPair(collectorCert, collectorKey) if err != nil { glog.Fatalf("Failed to use the collector certificate and key: %s", err) } tlsConfig.Certificates = []tls.Certificate{cert} tlsConfig.BuildNameToCertificate() } transport := &http.Transport{ TLSClientConfig: tlsConfig, } return http.Client{Transport: transport} } cadvisor-0.25.0/cadvisor_test.go000066400000000000000000000030511306035727200166140ustar00rootroot00000000000000// 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" "testing" "github.com/google/cadvisor/container" "github.com/stretchr/testify/assert" ) func TestTcpMetricsAreDisabledByDefault(t *testing.T) { assert.True(t, ignoreMetrics.Has(container.NetworkTcpUsageMetrics)) flag.Parse() assert.True(t, ignoreMetrics.Has(container.NetworkTcpUsageMetrics)) } func TestIgnoreMetrics(t *testing.T) { tests := []struct { value string expected []container.MetricKind }{ {"", []container.MetricKind{}}, {"disk", []container.MetricKind{container.DiskUsageMetrics}}, {"disk,tcp,network", []container.MetricKind{container.DiskUsageMetrics, container.NetworkTcpUsageMetrics, container.NetworkUsageMetrics}}, } for _, test := range tests { assert.NoError(t, ignoreMetrics.Set(test.value)) assert.Equal(t, len(test.expected), len(ignoreMetrics.MetricSet)) for _, expected := range test.expected { assert.True(t, ignoreMetrics.Has(expected), "Missing %s", expected) } } } cadvisor-0.25.0/client/000077500000000000000000000000001306035727200146735ustar00rootroot00000000000000cadvisor-0.25.0/client/README.md000066400000000000000000000034171306035727200161570ustar00rootroot00000000000000# Example REST API Client This is an implementation of a cAdvisor REST API in Go. You can use it like this: ```go client, err := client.NewClient("http://192.168.59.103:8080/") ``` Obviously, replace the URL with the path to your actual cAdvisor REST endpoint. ### MachineInfo ```go client.MachineInfo() ``` This method returns a cadvisor/v1.MachineInfo struct with all the fields filled in. Here is an example return value: ``` (*v1.MachineInfo)(0xc208022b10)({ NumCores: (int) 4, MemoryCapacity: (int64) 2106028032, Filesystems: ([]v1.FsInfo) (len=1 cap=4) { (v1.FsInfo) { Device: (string) (len=9) "/dev/sda1", Capacity: (uint64) 19507089408 } } }) ``` You can see the full specification of the [MachineInfo struct in the source](../info/v1/machine.go#L131) ### ContainerInfo Given a container name and a [ContainerInfoRequest](../info/v1/container.go#L101), will return all information about the specified container. See the [ContainerInfoRequest struct in the source](../info/v1/container.go#L101) for the full specification. ```go request := v1.ContainerInfoRequest{NumStats: 10} sInfo, err := client.ContainerInfo("/docker/d9d3eb10179e6f93a...", &request) ``` Returns a [ContainerInfo struct](../info/v1/container.go#L128) ### SubcontainersInfo Given a container name and a [ContainerInfoRequest](../info/v1/container.go#L101), will recursively return all info about the container and all subcontainers contained within the container. See the [ContainerInfoRequest struct in the source](../info/v1/container.go#L101) for the full specification. ```go request := v1.ContainerInfoRequest{NumStats: 10} sInfo, err := client.SubcontainersInfo("/docker", &request) ``` Returns a [ContainerInfo struct](../info/v1/container.go#L128) with the Subcontainers field populated. cadvisor-0.25.0/client/client.go000066400000000000000000000150621306035727200165040ustar00rootroot00000000000000// 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. // This is an implementation of a cAdvisor REST API in Go. // To use it, create a client (replace the URL with your actual cAdvisor REST endpoint): // client, err := client.NewClient("http://192.168.59.103:8080/") // Then, the client interface exposes go methods corresponding to the REST endpoints. package client import ( "bytes" "encoding/json" "fmt" "io" "io/ioutil" "net/http" "path" "strings" "github.com/google/cadvisor/info/v1" "github.com/golang/glog" ) // Client represents the base URL for a cAdvisor client. type Client struct { baseUrl string } // NewClient returns a new v1.3 client with the specified base URL. func NewClient(url string) (*Client, error) { if !strings.HasSuffix(url, "/") { url += "/" } return &Client{ baseUrl: fmt.Sprintf("%sapi/v1.3/", url), }, nil } // Returns all past events that satisfy the request func (self *Client) EventStaticInfo(name string) (einfo []*v1.Event, err error) { u := self.eventsInfoUrl(name) ret := new([]*v1.Event) if err = self.httpGetJsonData(ret, nil, u, "event info"); err != nil { return } einfo = *ret return } // Streams all events that occur that satisfy the request into the channel // that is passed func (self *Client) EventStreamingInfo(name string, einfo chan *v1.Event) (err error) { u := self.eventsInfoUrl(name) if err = self.getEventStreamingData(u, einfo); err != nil { return } return nil } // MachineInfo returns the JSON machine information for this client. // A non-nil error result indicates a problem with obtaining // the JSON machine information data. func (self *Client) MachineInfo() (minfo *v1.MachineInfo, err error) { u := self.machineInfoUrl() ret := new(v1.MachineInfo) if err = self.httpGetJsonData(ret, nil, u, "machine info"); err != nil { return } minfo = ret return } // ContainerInfo returns the JSON container information for the specified // container and request. func (self *Client) ContainerInfo(name string, query *v1.ContainerInfoRequest) (cinfo *v1.ContainerInfo, err error) { u := self.containerInfoUrl(name) ret := new(v1.ContainerInfo) if err = self.httpGetJsonData(ret, query, u, fmt.Sprintf("container info for %q", name)); err != nil { return } cinfo = ret return } // Returns the information about all subcontainers (recursive) of the specified container (including itself). func (self *Client) SubcontainersInfo(name string, query *v1.ContainerInfoRequest) ([]v1.ContainerInfo, error) { var response []v1.ContainerInfo url := self.subcontainersInfoUrl(name) err := self.httpGetJsonData(&response, query, url, fmt.Sprintf("subcontainers container info for %q", name)) if err != nil { return []v1.ContainerInfo{}, err } return response, nil } // Returns the JSON container information for the specified // Docker container and request. func (self *Client) DockerContainer(name string, query *v1.ContainerInfoRequest) (cinfo v1.ContainerInfo, err error) { u := self.dockerInfoUrl(name) ret := make(map[string]v1.ContainerInfo) if err = self.httpGetJsonData(&ret, query, u, fmt.Sprintf("Docker container info for %q", name)); err != nil { return } if len(ret) != 1 { err = fmt.Errorf("expected to only receive 1 Docker container: %+v", ret) return } for _, cont := range ret { cinfo = cont } return } // Returns the JSON container information for all Docker containers. func (self *Client) AllDockerContainers(query *v1.ContainerInfoRequest) (cinfo []v1.ContainerInfo, err error) { u := self.dockerInfoUrl("/") ret := make(map[string]v1.ContainerInfo) if err = self.httpGetJsonData(&ret, query, u, "all Docker containers info"); err != nil { return } cinfo = make([]v1.ContainerInfo, 0, len(ret)) for _, cont := range ret { cinfo = append(cinfo, cont) } return } func (self *Client) machineInfoUrl() string { return self.baseUrl + path.Join("machine") } func (self *Client) containerInfoUrl(name string) string { return self.baseUrl + path.Join("containers", name) } func (self *Client) subcontainersInfoUrl(name string) string { return self.baseUrl + path.Join("subcontainers", name) } func (self *Client) dockerInfoUrl(name string) string { return self.baseUrl + path.Join("docker", name) } func (self *Client) eventsInfoUrl(name string) string { return self.baseUrl + path.Join("events", name) } func (self *Client) httpGetJsonData(data, postData interface{}, url, infoName string) error { var resp *http.Response var err error if postData != nil { data, marshalErr := json.Marshal(postData) if marshalErr != nil { return fmt.Errorf("unable to marshal data: %v", marshalErr) } resp, err = http.Post(url, "application/json", bytes.NewBuffer(data)) } else { resp, err = http.Get(url) } if err != nil { return fmt.Errorf("unable to get %q from %q: %v", infoName, url, err) } if resp == nil { return fmt.Errorf("received empty response for %q from %q", infoName, url) } defer resp.Body.Close() body, err := ioutil.ReadAll(resp.Body) if err != nil { err = fmt.Errorf("unable to read all %q from %q: %v", infoName, url, err) return err } if resp.StatusCode != 200 { return fmt.Errorf("request %q failed with error: %q", url, strings.TrimSpace(string(body))) } if err = json.Unmarshal(body, data); err != nil { err = fmt.Errorf("unable to unmarshal %q (Body: %q) from %q with error: %v", infoName, string(body), url, err) return err } return nil } func (self *Client) getEventStreamingData(url string, einfo chan *v1.Event) error { req, err := http.NewRequest("GET", url, nil) if err != nil { return err } resp, err := http.DefaultClient.Do(req) if err != nil { return err } if resp.StatusCode != http.StatusOK { return fmt.Errorf("Status code is not OK: %v (%s)", resp.StatusCode, resp.Status) } dec := json.NewDecoder(resp.Body) var m *v1.Event = &v1.Event{} for { err := dec.Decode(m) if err != nil { if err == io.EOF { break } // if called without &stream=true will not be able to parse event and will trigger fatal glog.Fatalf("Received error %v", err) } einfo <- m } return nil } cadvisor-0.25.0/client/client_test.go000066400000000000000000000127321306035727200175440ustar00rootroot00000000000000// 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 client import ( "encoding/json" "fmt" "net/http" "net/http/httptest" "path" "reflect" "strings" "testing" "time" info "github.com/google/cadvisor/info/v1" itest "github.com/google/cadvisor/info/v1/test" "github.com/kr/pretty" ) func testGetJsonData( expected interface{}, f func() (interface{}, error), ) error { reply, err := f() if err != nil { return fmt.Errorf("unable to retrieve data: %v", err) } if !reflect.DeepEqual(reply, expected) { return pretty.Errorf("retrieved wrong data: %# v != %# v", reply, expected) } return nil } func cadvisorTestClient(path string, expectedPostObj *info.ContainerInfoRequest, replyObj interface{}, t *testing.T) (*Client, *httptest.Server, error) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if r.URL.Path == path { if expectedPostObj != nil { expectedPostObjEmpty := new(info.ContainerInfoRequest) decoder := json.NewDecoder(r.Body) if err := decoder.Decode(expectedPostObjEmpty); err != nil { t.Errorf("Received invalid object: %v", err) } if expectedPostObj.NumStats != expectedPostObjEmpty.NumStats || expectedPostObj.Start.Unix() != expectedPostObjEmpty.Start.Unix() || expectedPostObj.End.Unix() != expectedPostObjEmpty.End.Unix() { t.Errorf("Received unexpected object: %+v, expected: %+v", expectedPostObjEmpty, expectedPostObj) } } encoder := json.NewEncoder(w) encoder.Encode(replyObj) } 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 } // TestGetMachineInfo performs one test to check if MachineInfo() // in a cAdvisor client returns the correct result. func TestGetMachineinfo(t *testing.T) { minfo := &info.MachineInfo{ NumCores: 8, MemoryCapacity: 31625871360, DiskMap: map[string]info.DiskInfo{ "8:0": { Name: "sda", Major: 8, Minor: 0, Size: 10737418240, }, }, } client, server, err := cadvisorTestClient("/api/v1.3/machine", nil, minfo, t) if err != nil { t.Fatalf("unable to get a client %v", err) } defer server.Close() returned, err := client.MachineInfo() if err != nil { t.Fatal(err) } if !reflect.DeepEqual(returned, minfo) { t.Fatalf("received unexpected machine info") } } // TestGetContainerInfo generates a random container information object // and then checks that ContainerInfo returns the expected result. func TestGetContainerInfo(t *testing.T) { query := &info.ContainerInfoRequest{ NumStats: 3, } containerName := "/some/container" cinfo := itest.GenerateRandomContainerInfo(containerName, 4, query, 1*time.Second) client, server, err := cadvisorTestClient(fmt.Sprintf("/api/v1.3/containers%v", containerName), query, cinfo, t) if err != nil { t.Fatalf("unable to get a client %v", err) } defer server.Close() returned, err := client.ContainerInfo(containerName, query) if err != nil { t.Fatal(err) } if !returned.Eq(cinfo) { t.Error("received unexpected ContainerInfo") } } // Test a request failing func TestRequestFails(t *testing.T) { errorText := "there was an error" // Setup a server that simply fails. ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { http.Error(w, errorText, 500) })) client, err := NewClient(ts.URL) if err != nil { ts.Close() t.Fatal(err) } defer ts.Close() _, err = client.ContainerInfo("/", &info.ContainerInfoRequest{NumStats: 3}) if err == nil { t.Fatalf("Expected non-nil error") } expectedError := fmt.Sprintf("request failed with error: %q", errorText) if strings.Contains(err.Error(), expectedError) { t.Fatalf("Expected error %q but received %q", expectedError, err) } } func TestGetSubcontainersInfo(t *testing.T) { query := &info.ContainerInfoRequest{ NumStats: 3, } containerName := "/some/container" cinfo := itest.GenerateRandomContainerInfo(containerName, 4, query, 1*time.Second) cinfo1 := itest.GenerateRandomContainerInfo(path.Join(containerName, "sub1"), 4, query, 1*time.Second) cinfo2 := itest.GenerateRandomContainerInfo(path.Join(containerName, "sub2"), 4, query, 1*time.Second) response := []info.ContainerInfo{ *cinfo, *cinfo1, *cinfo2, } client, server, err := cadvisorTestClient(fmt.Sprintf("/api/v1.3/subcontainers%v", containerName), query, response, t) if err != nil { t.Fatalf("unable to get a client %v", err) } defer server.Close() returned, err := client.SubcontainersInfo(containerName, query) if err != nil { t.Fatal(err) } if len(returned) != 3 { t.Errorf("unexpected number of results: got %d, expected 3", len(returned)) } if !returned[0].Eq(cinfo) { t.Error("received unexpected ContainerInfo") } if !returned[1].Eq(cinfo1) { t.Error("received unexpected ContainerInfo") } if !returned[2].Eq(cinfo2) { t.Error("received unexpected ContainerInfo") } } cadvisor-0.25.0/client/clientexample/000077500000000000000000000000001306035727200175255ustar00rootroot00000000000000cadvisor-0.25.0/client/clientexample/main.go000066400000000000000000000034441306035727200210050ustar00rootroot00000000000000// 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" "github.com/google/cadvisor/client" info "github.com/google/cadvisor/info/v1" "github.com/golang/glog" ) func staticClientExample() { staticClient, err := client.NewClient("http://localhost:8080/") if err != nil { glog.Errorf("tried to make client and got error %v", err) return } einfo, err := staticClient.EventStaticInfo("?oom_events=true") if err != nil { glog.Errorf("got error retrieving event info: %v", err) return } for idx, ev := range einfo { glog.Infof("static einfo %v: %v", idx, ev) } } func streamingClientExample(url string) { streamingClient, err := client.NewClient("http://localhost:8080/") if err != nil { glog.Errorf("tried to make client and got error %v", err) return } einfo := make(chan *info.Event) go func() { err = streamingClient.EventStreamingInfo(url, einfo) if err != nil { glog.Errorf("got error retrieving event info: %v", err) return } }() for ev := range einfo { glog.Infof("streaming einfo: %v\n", ev) } } // demonstrates how to use event clients func main() { flag.Parse() staticClientExample() streamingClientExample("?creation_events=true&stream=true&oom_events=true&deletion_events=true") } cadvisor-0.25.0/client/v2/000077500000000000000000000000001306035727200152225ustar00rootroot00000000000000cadvisor-0.25.0/client/v2/README.md000066400000000000000000000033121306035727200165000ustar00rootroot00000000000000# Example REST API Client This is an implementation of a cAdvisor REST API in Go. You can use it like this: ```go client, err := client.NewClient("http://192.168.59.103:8080/") ``` Obviously, replace the URL with the path to your actual cAdvisor REST endpoint. ### MachineInfo ```go client.MachineInfo() ``` There is no v2 MachineInfo API, so the v2 client exposes the [v1 MachineInfo](../../info/v1/machine.go#L131) ``` (*v1.MachineInfo)(0xc208022b10)({ NumCores: (int) 4, MemoryCapacity: (int64) 2106028032, Filesystems: ([]v1.FsInfo) (len=1 cap=4) { (v1.FsInfo) { Device: (string) (len=9) "/dev/sda1", Capacity: (uint64) 19507089408 } } }) ``` You can see the full specification of the [MachineInfo struct in the source](../../info/v1/machine.go#L131) ### VersionInfo ```go client.VersionInfo() ``` This method returns the cAdvisor version. ### Attributes ```go client.Attributes() ``` This method returns a [cadvisor/info/v2/Attributes](../../info/v2/machine.go#L24) struct with all the fields filled in. Attributes includes hardware attributes (as returned by MachineInfo) as well as software attributes (eg. software versions). Here is an example return value: ``` (*v2.Attributes)({ KernelVersion: (string) (len=17) "3.13.0-44-generic" ContainerOsVersion: (string) (len=18) "Ubuntu 14.04.1 LTS" DockerVersion: (string) (len=9) "1.5.0-rc4" CadvisorVersion: (string) (len=6) "0.10.1" NumCores: (int) 4, MemoryCapacity: (int64) 2106028032, Filesystems: ([]v2.FsInfo) (len=1 cap=4) { (v2.FsInfo) { Device: (string) (len=9) "/dev/sda1", Capacity: (uint64) 19507089408 } } }) ``` You can see the full specification of the [Attributes struct in the source](../../info/v2/machine.go#L24) cadvisor-0.25.0/client/v2/client.go000066400000000000000000000117321306035727200170330ustar00rootroot00000000000000// Copyright 2015 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. // Client library to programmatically access cAdvisor API. package v2 import ( "bytes" "encoding/json" "fmt" "io/ioutil" "net/http" "net/url" "path" "strconv" "strings" v1 "github.com/google/cadvisor/info/v1" "github.com/google/cadvisor/info/v2" ) // Client represents the base URL for a cAdvisor client. type Client struct { baseUrl string } // NewClient returns a new client with the specified base URL. func NewClient(url string) (*Client, error) { if !strings.HasSuffix(url, "/") { url += "/" } return &Client{ baseUrl: fmt.Sprintf("%sapi/v2.1/", url), }, nil } // MachineInfo returns the JSON machine information for this client. // A non-nil error result indicates a problem with obtaining // the JSON machine information data. func (self *Client) MachineInfo() (minfo *v1.MachineInfo, err error) { u := self.machineInfoUrl() ret := new(v1.MachineInfo) if err = self.httpGetJsonData(ret, nil, u, "machine info"); err != nil { return } minfo = ret return } // MachineStats returns the JSON machine statistics for this client. // A non-nil error result indicates a problem with obtaining // the JSON machine information data. func (self *Client) MachineStats() ([]v2.MachineStats, error) { var ret []v2.MachineStats u := self.machineStatsUrl() err := self.httpGetJsonData(&ret, nil, u, "machine stats") return ret, err } // VersionInfo returns the version info for cAdvisor. func (self *Client) VersionInfo() (version string, err error) { u := self.versionInfoUrl() version, err = self.httpGetString(u, "version info") return } // Attributes returns hardware and software attributes of the machine. func (self *Client) Attributes() (attr *v2.Attributes, err error) { u := self.attributesUrl() ret := new(v2.Attributes) if err = self.httpGetJsonData(ret, nil, u, "attributes"); err != nil { return } attr = ret return } // Stats returns stats for the requested container. func (self *Client) Stats(name string, request *v2.RequestOptions) (map[string]v2.ContainerInfo, error) { u := self.statsUrl(name) ret := make(map[string]v2.ContainerInfo) data := url.Values{ "type": []string{request.IdType}, "count": []string{strconv.Itoa(request.Count)}, "recursive": []string{strconv.FormatBool(request.Recursive)}, } u = fmt.Sprintf("%s?%s", u, data.Encode()) if err := self.httpGetJsonData(&ret, nil, u, "stats"); err != nil { return nil, err } return ret, nil } func (self *Client) machineInfoUrl() string { return self.baseUrl + path.Join("machine") } func (self *Client) machineStatsUrl() string { return self.baseUrl + path.Join("machinestats") } func (self *Client) versionInfoUrl() string { return self.baseUrl + path.Join("version") } func (self *Client) attributesUrl() string { return self.baseUrl + path.Join("attributes") } func (self *Client) statsUrl(name string) string { return self.baseUrl + path.Join("stats", name) } func (self *Client) httpGetResponse(postData interface{}, urlPath, infoName string) ([]byte, error) { var resp *http.Response var err error if postData != nil { data, marshalErr := json.Marshal(postData) if marshalErr != nil { return nil, fmt.Errorf("unable to marshal data: %v", marshalErr) } resp, err = http.Post(urlPath, "application/json", bytes.NewBuffer(data)) } else { resp, err = http.Get(urlPath) } if err != nil { return nil, fmt.Errorf("unable to post %q to %q: %v", infoName, urlPath, err) } if resp == nil { return nil, fmt.Errorf("received empty response for %q from %q", infoName, urlPath) } defer resp.Body.Close() body, err := ioutil.ReadAll(resp.Body) if err != nil { err = fmt.Errorf("unable to read all %q from %q: %v", infoName, urlPath, err) return nil, err } if resp.StatusCode != 200 { return nil, fmt.Errorf("request %q failed with error: %q", urlPath, strings.TrimSpace(string(body))) } return body, nil } func (self *Client) httpGetString(url, infoName string) (string, error) { body, err := self.httpGetResponse(nil, url, infoName) if err != nil { return "", err } return string(body), nil } func (self *Client) httpGetJsonData(data, postData interface{}, url, infoName string) error { body, err := self.httpGetResponse(postData, url, infoName) if err != nil { return err } if err = json.Unmarshal(body, data); err != nil { err = fmt.Errorf("unable to unmarshal %q (Body: %q) from %q with error: %v", infoName, string(body), url, err) return err } return nil } cadvisor-0.25.0/client/v2/client_test.go000066400000000000000000000136371306035727200201000ustar00rootroot00000000000000// Copyright 2015 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 v2 import ( "encoding/json" "fmt" "net/http" "net/http/httptest" "reflect" "strings" "testing" "time" "github.com/google/cadvisor/info/v1" "github.com/google/cadvisor/info/v2" "github.com/stretchr/testify/assert" "github.com/kr/pretty" ) func testGetJsonData( expected interface{}, f func() (interface{}, error), ) error { reply, err := f() if err != nil { return fmt.Errorf("unable to retrieve data: %v", err) } if !reflect.DeepEqual(reply, expected) { return pretty.Errorf("retrieved wrong data: %# v != %# v", reply, expected) } return nil } func cadvisorTestClient(path string, expectedPostObj *v1.ContainerInfoRequest, replyObj interface{}, t *testing.T) (*Client, *httptest.Server, error) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if r.URL.Path == path { if expectedPostObj != nil { expectedPostObjEmpty := new(v1.ContainerInfoRequest) decoder := json.NewDecoder(r.Body) if err := decoder.Decode(expectedPostObjEmpty); err != nil { t.Errorf("Received invalid object: %v", err) } if expectedPostObj.NumStats != expectedPostObjEmpty.NumStats || expectedPostObj.Start.Unix() != expectedPostObjEmpty.Start.Unix() || expectedPostObj.End.Unix() != expectedPostObjEmpty.End.Unix() { t.Errorf("Received unexpected object: %+v, expected: %+v", expectedPostObjEmpty, expectedPostObj) } } encoder := json.NewEncoder(w) encoder.Encode(replyObj) } else if r.URL.Path == "/api/v2.1/version" { fmt.Fprintf(w, "0.1.2") } 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 } // TestGetMachineInfo performs one test to check if MachineInfo() // in a cAdvisor client returns the correct result. func TestGetMachineInfo(t *testing.T) { mv1 := &v1.MachineInfo{ NumCores: 8, MemoryCapacity: 31625871360, DiskMap: map[string]v1.DiskInfo{ "8:0": { Name: "sda", Major: 8, Minor: 0, Size: 10737418240, }, }, } client, server, err := cadvisorTestClient("/api/v2.1/machine", nil, mv1, t) if err != nil { t.Fatalf("unable to get a client %v", err) } defer server.Close() returned, err := client.MachineInfo() if err != nil { t.Fatal(err) } if !reflect.DeepEqual(returned, mv1) { t.Fatalf("received unexpected machine v1") } } // TestGetVersionV1 performs one test to check if VersionV1() // in a cAdvisor client returns the correct result. func TestGetVersionv1(t *testing.T) { version := "0.1.2" client, server, err := cadvisorTestClient("", nil, version, t) if err != nil { t.Fatalf("unable to get a client %v", err) } defer server.Close() returned, err := client.VersionInfo() if err != nil { t.Fatal(err) } if returned != version { t.Fatalf("received unexpected version v1") } } // TestAttributes performs one test to check if Attributes() // in a cAdvisor client returns the correct result. func TestGetAttributes(t *testing.T) { attr := &v2.Attributes{ KernelVersion: "3.3.0", ContainerOsVersion: "Ubuntu 14.4", DockerVersion: "Docker 1.5", CadvisorVersion: "0.1.2", NumCores: 8, MemoryCapacity: 31625871360, DiskMap: map[string]v1.DiskInfo{ "8:0": { Name: "sda", Major: 8, Minor: 0, Size: 10737418240, }, }, } client, server, err := cadvisorTestClient("/api/v2.1/attributes", nil, attr, t) if err != nil { t.Fatalf("unable to get a client %v", err) } defer server.Close() returned, err := client.Attributes() if err != nil { t.Fatal(err) } if !reflect.DeepEqual(returned, attr) { t.Fatalf("received unexpected attributes") } } // TestMachineStats performs one test to check if MachineStats() // in a cAdvisor client returns the correct result. func TestMachineStats(t *testing.T) { machineStats := []v2.MachineStats{ { Timestamp: time.Now(), Cpu: &v1.CpuStats{ Usage: v1.CpuUsage{ Total: 100000, }, LoadAverage: 10, }, Filesystem: []v2.MachineFsStats{ { Device: "sda1", }, }, }, } client, server, err := cadvisorTestClient("/api/v2.1/machinestats", nil, &machineStats, t) if err != nil { t.Fatalf("unable to get a client %v", err) } defer server.Close() returned, err := client.MachineStats() if err != nil { t.Fatal(err) } assert.Len(t, returned, len(machineStats)) if !reflect.DeepEqual(returned[0].Cpu, machineStats[0].Cpu) { t.Fatalf("received unexpected machine stats\nExp: %+v\nAct: %+v", machineStats, returned) } if !reflect.DeepEqual(returned[0].Filesystem, machineStats[0].Filesystem) { t.Fatalf("received unexpected machine stats\nExp: %+v\nAct: %+v", machineStats, returned) } } func TestRequestFails(t *testing.T) { errorText := "there was an error" // Setup a server that simply fails. ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { http.Error(w, errorText, 500) })) client, err := NewClient(ts.URL) if err != nil { ts.Close() t.Fatal(err) } defer ts.Close() _, err = client.MachineInfo() if err == nil { t.Fatalf("Expected non-nil error") } expectedError := fmt.Sprintf("request failed with error: %q", errorText) if strings.Contains(err.Error(), expectedError) { t.Fatalf("Expected error %q but received %q", expectedError, err) } } cadvisor-0.25.0/collector/000077500000000000000000000000001306035727200154035ustar00rootroot00000000000000cadvisor-0.25.0/collector/collector_manager.go000066400000000000000000000055551306035727200214240ustar00rootroot00000000000000// Copyright 2015 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 collector import ( "fmt" "strings" "time" "github.com/google/cadvisor/info/v1" ) const metricLabelPrefix = "io.cadvisor.metric." type GenericCollectorManager struct { Collectors []*collectorData NextCollectionTime time.Time } type collectorData struct { collector Collector nextCollectionTime time.Time } // Returns a new CollectorManager that is thread-compatible. func NewCollectorManager() (CollectorManager, error) { return &GenericCollectorManager{ Collectors: []*collectorData{}, NextCollectionTime: time.Now(), }, nil } func GetCollectorConfigs(labels map[string]string) map[string]string { configs := map[string]string{} for k, v := range labels { if strings.HasPrefix(k, metricLabelPrefix) { name := strings.TrimPrefix(k, metricLabelPrefix) configs[name] = v } } return configs } func (cm *GenericCollectorManager) RegisterCollector(collector Collector) error { cm.Collectors = append(cm.Collectors, &collectorData{ collector: collector, nextCollectionTime: time.Now(), }) return nil } func (cm *GenericCollectorManager) GetSpec() ([]v1.MetricSpec, error) { metricSpec := []v1.MetricSpec{} for _, c := range cm.Collectors { specs := c.collector.GetSpec() metricSpec = append(metricSpec, specs...) } return metricSpec, nil } func (cm *GenericCollectorManager) Collect() (time.Time, map[string][]v1.MetricVal, error) { var errors []error // Collect from all collectors that are ready. var next time.Time metrics := map[string][]v1.MetricVal{} for _, c := range cm.Collectors { if c.nextCollectionTime.Before(time.Now()) { var err error c.nextCollectionTime, metrics, err = c.collector.Collect(metrics) if err != nil { errors = append(errors, err) } } // Keep track of the next collector that will be ready. if next.IsZero() || next.After(c.nextCollectionTime) { next = c.nextCollectionTime } } cm.NextCollectionTime = next return next, metrics, compileErrors(errors) } // Make an error slice into a single error. func compileErrors(errors []error) error { if len(errors) == 0 { return nil } res := make([]string, len(errors)) for i := range errors { res[i] = fmt.Sprintf("Error %d: %v", i, errors[i].Error()) } return fmt.Errorf("%s", strings.Join(res, ",")) } cadvisor-0.25.0/collector/collector_manager_test.go000066400000000000000000000040221306035727200224470ustar00rootroot00000000000000// Copyright 2015 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 collector import ( "testing" "time" "github.com/google/cadvisor/info/v1" "github.com/stretchr/testify/assert" ) type fakeCollector struct { nextCollectionTime time.Time err error collectedFrom int } func (fc *fakeCollector) Collect(metric map[string][]v1.MetricVal) (time.Time, map[string][]v1.MetricVal, error) { fc.collectedFrom++ return fc.nextCollectionTime, metric, fc.err } func (fc *fakeCollector) Name() string { return "fake-collector" } func (fc *fakeCollector) GetSpec() []v1.MetricSpec { return []v1.MetricSpec{} } func TestCollect(t *testing.T) { cm := &GenericCollectorManager{} firstTime := time.Now().Add(-time.Hour) secondTime := time.Now().Add(time.Hour) f1 := &fakeCollector{ nextCollectionTime: firstTime, } f2 := &fakeCollector{ nextCollectionTime: secondTime, } assert := assert.New(t) assert.NoError(cm.RegisterCollector(f1)) assert.NoError(cm.RegisterCollector(f2)) // First collection, everyone gets collected from. nextTime, _, err := cm.Collect() assert.Equal(firstTime, nextTime) assert.NoError(err) assert.Equal(1, f1.collectedFrom) assert.Equal(1, f2.collectedFrom) f1.nextCollectionTime = time.Now().Add(2 * time.Hour) // Second collection, only the one that is ready gets collected from. nextTime, _, err = cm.Collect() assert.Equal(secondTime, nextTime) assert.NoError(err) assert.Equal(2, f1.collectedFrom) assert.Equal(1, f2.collectedFrom) } cadvisor-0.25.0/collector/config.go000066400000000000000000000053451306035727200172060ustar00rootroot00000000000000// Copyright 2015 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 collector import ( "time" "encoding/json" "github.com/google/cadvisor/info/v1" ) type Config struct { // the endpoint to hit to scrape metrics Endpoint EndpointConfig `json:"endpoint"` // holds information about different metrics that can be collected MetricsConfig []MetricConfig `json:"metrics_config"` } // metricConfig holds information extracted from the config file about a metric type MetricConfig struct { // the name of the metric Name string `json:"name"` // enum type for the metric type MetricType v1.MetricType `json:"metric_type"` // metric units to display on UI and in storage (eg: MB, cores) // this is only used for display. Units string `json:"units"` // data type of the metric (eg: int, float) DataType v1.DataType `json:"data_type"` // the frequency at which the metric should be collected PollingFrequency time.Duration `json:"polling_frequency"` // the regular expression that can be used to extract the metric Regex string `json:"regex"` } type Prometheus struct { // the endpoint to hit to scrape metrics Endpoint EndpointConfig `json:"endpoint"` // the frequency at which metrics should be collected PollingFrequency time.Duration `json:"polling_frequency"` // holds names of different metrics that can be collected MetricsConfig []string `json:"metrics_config"` } type EndpointConfig struct { // The full URL of the endpoint to reach URL string // A configuration in which an actual URL is constructed from, using the container's ip address URLConfig URLConfig } type URLConfig struct { // the protocol to use for connecting to the endpoint. Eg 'http' or 'https' Protocol string `json:"protocol"` // the port to use for connecting to the endpoint. Eg '8778' Port json.Number `json:"port"` // the path to use for the endpoint. Eg '/metrics' Path string `json:"path"` } func (ec *EndpointConfig) UnmarshalJSON(b []byte) error { url := "" config := URLConfig{ Protocol: "http", Port: "8000", } if err := json.Unmarshal(b, &url); err == nil { ec.URL = url return nil } err := json.Unmarshal(b, &config) if err == nil { ec.URLConfig = config return nil } return err } cadvisor-0.25.0/collector/config/000077500000000000000000000000001306035727200166505ustar00rootroot00000000000000cadvisor-0.25.0/collector/config/sample_config.json000066400000000000000000000020151306035727200223470ustar00rootroot00000000000000{ "endpoint" : "http://localhost:8000/nginx_status", "metrics_config" : [ { "name" : "activeConnections", "metric_type" : "gauge", "units" : "number of active connections", "data_type" : "int", "polling_frequency" : 10, "regex" : "Active connections: ([0-9]+)" }, { "name" : "reading", "metric_type" : "gauge", "units" : "number of reading connections", "data_type" : "int", "polling_frequency" : 10, "regex" : "Reading: ([0-9]+) .*" }, { "name" : "writing", "metric_type" : "gauge", "data_type" : "int", "units" : "number of writing connections", "polling_frequency" : 10, "regex" : ".*Writing: ([0-9]+).*" }, { "name" : "waiting", "metric_type" : "gauge", "units" : "number of waiting connections", "data_type" : "int", "polling_frequency" : 10, "regex" : ".*Waiting: ([0-9]+)" } ] } cadvisor-0.25.0/collector/config/sample_config_endpoint_config.json000066400000000000000000000017321306035727200256010ustar00rootroot00000000000000{ "endpoint" : { "protocol": "https", "port": 8000, "path": "/nginx_status" }, "metrics_config" : [ { "name" : "activeConnections", "metric_type" : "gauge", "units" : "number of active connections", "data_type" : "int", "polling_frequency" : 10, "regex" : "Active connections: ([0-9]+)" }, { "name" : "reading", "metric_type" : "gauge", "units" : "number of reading connections", "data_type" : "int", "polling_frequency" : 10, "regex" : "Reading: ([0-9]+) .*" }, { "name" : "writing", "metric_type" : "gauge", "data_type" : "int", "units" : "number of writing connections", "polling_frequency" : 10, "regex" : ".*Writing: ([0-9]+).*" }, { "name" : "waiting", "metric_type" : "gauge", "units" : "number of waiting connections", "data_type" : "int", "polling_frequency" : 10, "regex" : ".*Waiting: ([0-9]+)" } ] } cadvisor-0.25.0/collector/config/sample_config_prometheus.json000066400000000000000000000001751306035727200246270ustar00rootroot00000000000000{ "endpoint" : "http://localhost:8080/metrics", "polling_frequency" : 10, "metrics_config" : [ ] } cadvisor-0.25.0/collector/config/sample_config_prometheus_endpoint_config.json000066400000000000000000000002211306035727200300440ustar00rootroot00000000000000{ "endpoint" : { "protocol": "http", "port": 8081, "path": "/METRICS" }, "polling_frequency" : 10, "metrics_config" : [ ] }cadvisor-0.25.0/collector/config/sample_config_prometheus_filtered.json000066400000000000000000000002631306035727200265030ustar00rootroot00000000000000{ "endpoint" : "http://localhost:8080/metrics", "polling_frequency" : 10, "metrics_config" : [ "go_goroutines", "qps" ] } cadvisor-0.25.0/collector/fakes.go000066400000000000000000000021101306035727200170150ustar00rootroot00000000000000// Copyright 2015 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 collector import ( "time" "github.com/google/cadvisor/info/v1" ) type FakeCollectorManager struct { } func (fkm *FakeCollectorManager) RegisterCollector(collector Collector) error { return nil } func (fkm *FakeCollectorManager) GetSpec() ([]v1.MetricSpec, error) { return []v1.MetricSpec{}, nil } func (fkm *FakeCollectorManager) Collect(metric map[string][]v1.MetricVal) (time.Time, map[string][]v1.MetricVal, error) { var zero time.Time return zero, metric, nil } cadvisor-0.25.0/collector/generic_collector.go000066400000000000000000000130301306035727200214110ustar00rootroot00000000000000// Copyright 2015 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 collector import ( "encoding/json" "fmt" "io/ioutil" "net/http" "regexp" "strconv" "strings" "time" "github.com/google/cadvisor/container" "github.com/google/cadvisor/info/v1" ) type GenericCollector struct { // name of the collector name string // holds information extracted from the config file for a collector configFile Config // holds information necessary to extract metrics info *collectorInfo // The Http client to use when connecting to metric endpoints httpClient *http.Client } type collectorInfo struct { // minimum polling frequency among all metrics minPollingFrequency time.Duration // regular expresssions for all metrics regexps []*regexp.Regexp // Limit for the number of srcaped metrics. If the count is higher, // no metrics will be returned. metricCountLimit int } // Returns a new collector using the information extracted from the configfile func NewCollector(collectorName string, configFile []byte, metricCountLimit int, containerHandler container.ContainerHandler, httpClient *http.Client) (*GenericCollector, error) { var configInJSON Config err := json.Unmarshal(configFile, &configInJSON) if err != nil { return nil, err } configInJSON.Endpoint.configure(containerHandler) // TODO : Add checks for validity of config file (eg : Accurate JSON fields) if len(configInJSON.MetricsConfig) == 0 { return nil, fmt.Errorf("No metrics provided in config") } minPollFrequency := time.Duration(0) regexprs := make([]*regexp.Regexp, len(configInJSON.MetricsConfig)) for ind, metricConfig := range configInJSON.MetricsConfig { // Find the minimum specified polling frequency in metric config. if metricConfig.PollingFrequency != 0 { if minPollFrequency == 0 || metricConfig.PollingFrequency < minPollFrequency { minPollFrequency = metricConfig.PollingFrequency } } regexprs[ind], err = regexp.Compile(metricConfig.Regex) if err != nil { return nil, fmt.Errorf("Invalid regexp %v for metric %v", metricConfig.Regex, metricConfig.Name) } } // Minimum supported polling frequency is 1s. minSupportedFrequency := 1 * time.Second if minPollFrequency < minSupportedFrequency { minPollFrequency = minSupportedFrequency } if len(configInJSON.MetricsConfig) > metricCountLimit { return nil, fmt.Errorf("Too many metrics defined: %d limit: %d", len(configInJSON.MetricsConfig), metricCountLimit) } return &GenericCollector{ name: collectorName, configFile: configInJSON, info: &collectorInfo{ minPollingFrequency: minPollFrequency, regexps: regexprs, metricCountLimit: metricCountLimit, }, httpClient: httpClient, }, nil } // Returns name of the collector func (collector *GenericCollector) Name() string { return collector.name } func (collector *GenericCollector) configToSpec(config MetricConfig) v1.MetricSpec { return v1.MetricSpec{ Name: config.Name, Type: config.MetricType, Format: config.DataType, Units: config.Units, } } func (collector *GenericCollector) GetSpec() []v1.MetricSpec { specs := []v1.MetricSpec{} for _, metricConfig := range collector.configFile.MetricsConfig { spec := collector.configToSpec(metricConfig) specs = append(specs, spec) } return specs } // Returns collected metrics and the next collection time of the collector func (collector *GenericCollector) Collect(metrics map[string][]v1.MetricVal) (time.Time, map[string][]v1.MetricVal, error) { currentTime := time.Now() nextCollectionTime := currentTime.Add(time.Duration(collector.info.minPollingFrequency)) uri := collector.configFile.Endpoint.URL response, err := collector.httpClient.Get(uri) if err != nil { return nextCollectionTime, nil, err } defer response.Body.Close() pageContent, err := ioutil.ReadAll(response.Body) if err != nil { return nextCollectionTime, nil, err } var errorSlice []error for ind, metricConfig := range collector.configFile.MetricsConfig { matchString := collector.info.regexps[ind].FindStringSubmatch(string(pageContent)) if matchString != nil { if metricConfig.DataType == v1.FloatType { regVal, err := strconv.ParseFloat(strings.TrimSpace(matchString[1]), 64) if err != nil { errorSlice = append(errorSlice, err) } metrics[metricConfig.Name] = []v1.MetricVal{ {FloatValue: regVal, Timestamp: currentTime}, } } else if metricConfig.DataType == v1.IntType { regVal, err := strconv.ParseInt(strings.TrimSpace(matchString[1]), 10, 64) if err != nil { errorSlice = append(errorSlice, err) } metrics[metricConfig.Name] = []v1.MetricVal{ {IntValue: regVal, Timestamp: currentTime}, } } else { errorSlice = append(errorSlice, fmt.Errorf("Unexpected value of 'data_type' for metric '%v' in config ", metricConfig.Name)) } } else { errorSlice = append(errorSlice, fmt.Errorf("No match found for regexp: %v for metric '%v' in config", metricConfig.Regex, metricConfig.Name)) } } return nextCollectionTime, metrics, compileErrors(errorSlice) } cadvisor-0.25.0/collector/generic_collector_test.go000066400000000000000000000154251306035727200224620ustar00rootroot00000000000000// Copyright 2015 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 collector import ( "fmt" "io/ioutil" "net/http" "net/http/httptest" "os" "testing" "github.com/google/cadvisor/info/v1" containertest "github.com/google/cadvisor/container/testing" "github.com/stretchr/testify/assert" ) func TestEmptyConfig(t *testing.T) { assert := assert.New(t) emptyConfig := ` { "endpoint" : "http://localhost:8000/nginx_status", "metrics_config" : [ ] } ` // Create a temporary config file 'temp.json' with invalid json format assert.NoError(ioutil.WriteFile("temp.json", []byte(emptyConfig), 0777)) configFile, err := ioutil.ReadFile("temp.json") assert.NoError(err) containerHandler := containertest.NewMockContainerHandler("mockContainer") _, err = NewCollector("tempCollector", configFile, 100, containerHandler, http.DefaultClient) assert.Error(err) assert.NoError(os.Remove("temp.json")) } func TestConfigWithErrors(t *testing.T) { assert := assert.New(t) // Syntax error: Missed '"' after activeConnections invalid := ` { "endpoint" : "http://localhost:8000/nginx_status", "metrics_config" : [ { "name" : "activeConnections, "metric_type" : "gauge", "data_type" : "int", "polling_frequency" : 10, "regex" : "Active connections: ([0-9]+)" } ] } ` // Create a temporary config file 'temp.json' with invalid json format assert.NoError(ioutil.WriteFile("temp.json", []byte(invalid), 0777)) configFile, err := ioutil.ReadFile("temp.json") assert.NoError(err) containerHandler := containertest.NewMockContainerHandler("mockContainer") _, err = NewCollector("tempCollector", configFile, 100, containerHandler, http.DefaultClient) assert.Error(err) assert.NoError(os.Remove("temp.json")) } func TestConfigWithRegexErrors(t *testing.T) { assert := assert.New(t) // Error: Missed operand for '+' in activeConnections regex invalid := ` { "endpoint" : "host:port/nginx_status", "metrics_config" : [ { "name" : "activeConnections", "metric_type" : "gauge", "data_type" : "int", "polling_frequency" : 10, "regex" : "Active connections: (+)" }, { "name" : "reading", "metric_type" : "gauge", "data_type" : "int", "polling_frequency" : 10, "regex" : "Reading: ([0-9]+) .*" } ] } ` // Create a temporary config file 'temp.json' assert.NoError(ioutil.WriteFile("temp.json", []byte(invalid), 0777)) configFile, err := ioutil.ReadFile("temp.json") assert.NoError(err) containerHandler := containertest.NewMockContainerHandler("mockContainer") _, err = NewCollector("tempCollector", configFile, 100, containerHandler, http.DefaultClient) assert.Error(err) assert.NoError(os.Remove("temp.json")) } func TestConfig(t *testing.T) { assert := assert.New(t) // Create an nginx collector using the config file 'sample_config.json' configFile, err := ioutil.ReadFile("config/sample_config.json") assert.NoError(err) containerHandler := containertest.NewMockContainerHandler("mockContainer") collector, err := NewCollector("nginx", configFile, 100, containerHandler, http.DefaultClient) assert.NoError(err) assert.Equal(collector.name, "nginx") assert.Equal(collector.configFile.Endpoint.URL, "http://localhost:8000/nginx_status") assert.Equal(collector.configFile.MetricsConfig[0].Name, "activeConnections") } func TestEndpointConfig(t *testing.T) { assert := assert.New(t) configFile, err := ioutil.ReadFile("config/sample_config_endpoint_config.json") assert.NoError(err) containerHandler := containertest.NewMockContainerHandler("mockContainer") containerHandler.On("GetContainerIPAddress").Return( "111.111.111.111", ) collector, err := NewCollector("nginx", configFile, 100, containerHandler, http.DefaultClient) assert.NoError(err) assert.Equal(collector.name, "nginx") assert.Equal(collector.configFile.Endpoint.URL, "https://111.111.111.111:8000/nginx_status") assert.Equal(collector.configFile.MetricsConfig[0].Name, "activeConnections") } func TestMetricCollection(t *testing.T) { assert := assert.New(t) // Collect nginx metrics from a fake nginx endpoint configFile, err := ioutil.ReadFile("config/sample_config.json") assert.NoError(err) containerHandler := containertest.NewMockContainerHandler("mockContainer") fakeCollector, err := NewCollector("nginx", configFile, 100, containerHandler, http.DefaultClient) assert.NoError(err) tempServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { fmt.Fprintln(w, "Active connections: 3\nserver accepts handled requests") fmt.Fprintln(w, "5 5 32\nReading: 0 Writing: 1 Waiting: 2") })) defer tempServer.Close() fakeCollector.configFile.Endpoint.URL = tempServer.URL metrics := map[string][]v1.MetricVal{} _, metrics, errMetric := fakeCollector.Collect(metrics) assert.NoError(errMetric) metricNames := []string{"activeConnections", "reading", "writing", "waiting"} // activeConnections = 3 assert.Equal(metrics[metricNames[0]][0].IntValue, 3) assert.Equal(metrics[metricNames[0]][0].FloatValue, 0) // reading = 0 assert.Equal(metrics[metricNames[1]][0].IntValue, 0) assert.Equal(metrics[metricNames[1]][0].FloatValue, 0) // writing = 1 assert.Equal(metrics[metricNames[2]][0].IntValue, 1) assert.Equal(metrics[metricNames[2]][0].FloatValue, 0) // waiting = 2 assert.Equal(metrics[metricNames[3]][0].IntValue, 2) assert.Equal(metrics[metricNames[3]][0].FloatValue, 0) } func TestMetricCollectionLimit(t *testing.T) { assert := assert.New(t) // Collect nginx metrics from a fake nginx endpoint configFile, err := ioutil.ReadFile("config/sample_config.json") assert.NoError(err) containerHandler := containertest.NewMockContainerHandler("mockContainer") _, err = NewCollector("nginx", configFile, 1, containerHandler, http.DefaultClient) assert.Error(err) } cadvisor-0.25.0/collector/prometheus_collector.go000066400000000000000000000171151306035727200222000ustar00rootroot00000000000000// Copyright 2015 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 collector import ( "bytes" "encoding/json" "fmt" "io" "net/http" "sort" "time" rawmodel "github.com/prometheus/client_model/go" "github.com/prometheus/common/expfmt" "github.com/prometheus/common/model" "github.com/google/cadvisor/container" "github.com/google/cadvisor/info/v1" ) type PrometheusCollector struct { // name of the collector name string // rate at which metrics are collected pollingFrequency time.Duration // holds information extracted from the config file for a collector configFile Prometheus // the metrics to gather (uses a map as a set) metricsSet map[string]bool // Limit for the number of scaped metrics. If the count is higher, // no metrics will be returned. metricCountLimit int // The Http client to use when connecting to metric endpoints httpClient *http.Client } // Returns a new collector using the information extracted from the configfile func NewPrometheusCollector(collectorName string, configFile []byte, metricCountLimit int, containerHandler container.ContainerHandler, httpClient *http.Client) (*PrometheusCollector, error) { var configInJSON Prometheus err := json.Unmarshal(configFile, &configInJSON) if err != nil { return nil, err } configInJSON.Endpoint.configure(containerHandler) minPollingFrequency := configInJSON.PollingFrequency // Minimum supported frequency is 1s minSupportedFrequency := 1 * time.Second if minPollingFrequency < minSupportedFrequency { minPollingFrequency = minSupportedFrequency } if metricCountLimit < 0 { return nil, fmt.Errorf("Metric count limit must be greater than 0") } var metricsSet map[string]bool if len(configInJSON.MetricsConfig) > 0 { metricsSet = make(map[string]bool, len(configInJSON.MetricsConfig)) for _, name := range configInJSON.MetricsConfig { metricsSet[name] = true } } if len(configInJSON.MetricsConfig) > metricCountLimit { return nil, fmt.Errorf("Too many metrics defined: %d limit %d", len(configInJSON.MetricsConfig), metricCountLimit) } // TODO : Add checks for validity of config file (eg : Accurate JSON fields) return &PrometheusCollector{ name: collectorName, pollingFrequency: minPollingFrequency, configFile: configInJSON, metricsSet: metricsSet, metricCountLimit: metricCountLimit, httpClient: httpClient, }, nil } // Returns name of the collector func (collector *PrometheusCollector) Name() string { return collector.name } func (collector *PrometheusCollector) GetSpec() []v1.MetricSpec { response, err := collector.httpClient.Get(collector.configFile.Endpoint.URL) if err != nil { return nil } defer response.Body.Close() if response.StatusCode != http.StatusOK { return nil } dec := expfmt.NewDecoder(response.Body, expfmt.ResponseFormat(response.Header)) var specs []v1.MetricSpec for { d := rawmodel.MetricFamily{} if err = dec.Decode(&d); err != nil { break } name := d.GetName() if len(name) == 0 { continue } // If metrics to collect is specified, skip any metrics not in the list to collect. if _, ok := collector.metricsSet[name]; collector.metricsSet != nil && !ok { continue } spec := v1.MetricSpec{ Name: name, Type: metricType(d.GetType()), Format: v1.FloatType, } specs = append(specs, spec) } if err != nil && err != io.EOF { return nil } return specs } // metricType converts Prometheus metric type to cadvisor metric type. // If there is no mapping then just return the name of the Prometheus metric type. func metricType(t rawmodel.MetricType) v1.MetricType { switch t { case rawmodel.MetricType_COUNTER: return v1.MetricCumulative case rawmodel.MetricType_GAUGE: return v1.MetricGauge default: return v1.MetricType(t.String()) } } type prometheusLabels []*rawmodel.LabelPair func labelSetToLabelPairs(labels model.Metric) prometheusLabels { var promLabels prometheusLabels for k, v := range labels { name := string(k) value := string(v) promLabels = append(promLabels, &rawmodel.LabelPair{Name: &name, Value: &value}) } return promLabels } func (s prometheusLabels) Len() int { return len(s) } func (s prometheusLabels) Swap(i, j int) { s[i], s[j] = s[j], s[i] } // ByName implements sort.Interface by providing Less and using the Len and // Swap methods of the embedded PrometheusLabels value. type byName struct{ prometheusLabels } func (s byName) Less(i, j int) bool { return s.prometheusLabels[i].GetName() < s.prometheusLabels[j].GetName() } func prometheusLabelSetToCadvisorLabel(promLabels model.Metric) string { labels := labelSetToLabelPairs(promLabels) sort.Sort(byName{labels}) var b bytes.Buffer for i, l := range labels { if i > 0 { b.WriteString("\xff") } b.WriteString(l.GetName()) b.WriteString("=") b.WriteString(l.GetValue()) } return string(b.Bytes()) } // Returns collected metrics and the next collection time of the collector func (collector *PrometheusCollector) Collect(metrics map[string][]v1.MetricVal) (time.Time, map[string][]v1.MetricVal, error) { currentTime := time.Now() nextCollectionTime := currentTime.Add(time.Duration(collector.pollingFrequency)) uri := collector.configFile.Endpoint.URL response, err := collector.httpClient.Get(uri) if err != nil { return nextCollectionTime, nil, err } defer response.Body.Close() if response.StatusCode != http.StatusOK { return nextCollectionTime, nil, fmt.Errorf("server returned HTTP status %s", response.Status) } sdec := expfmt.SampleDecoder{ Dec: expfmt.NewDecoder(response.Body, expfmt.ResponseFormat(response.Header)), Opts: &expfmt.DecodeOptions{ Timestamp: model.TimeFromUnixNano(currentTime.UnixNano()), }, } var ( // 50 is chosen as a reasonable guesstimate at a number of metrics we can // expect from virtually any endpoint to try to save allocations. decSamples = make(model.Vector, 0, 50) newMetrics = make(map[string][]v1.MetricVal) ) for { if err = sdec.Decode(&decSamples); err != nil { break } for _, sample := range decSamples { metName := string(sample.Metric[model.MetricNameLabel]) if len(metName) == 0 { continue } // If metrics to collect is specified, skip any metrics not in the list to collect. if _, ok := collector.metricsSet[metName]; collector.metricsSet != nil && !ok { continue } // TODO Handle multiple labels nicer. Prometheus metrics can have multiple // labels, cadvisor only accepts a single string for the metric label. label := prometheusLabelSetToCadvisorLabel(sample.Metric) metric := v1.MetricVal{ FloatValue: float64(sample.Value), Timestamp: sample.Timestamp.Time(), Label: label, } newMetrics[metName] = append(newMetrics[metName], metric) if len(newMetrics) > collector.metricCountLimit { return nextCollectionTime, nil, fmt.Errorf("too many metrics to collect") } } decSamples = decSamples[:0] } if err != nil && err != io.EOF { return nextCollectionTime, nil, err } for key, val := range newMetrics { metrics[key] = append(metrics[key], val...) } return nextCollectionTime, metrics, nil } cadvisor-0.25.0/collector/prometheus_collector_test.go000066400000000000000000000215401306035727200232340ustar00rootroot00000000000000// Copyright 2015 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 collector import ( "fmt" "io/ioutil" "net/http" "net/http/httptest" "testing" "github.com/google/cadvisor/info/v1" containertest "github.com/google/cadvisor/container/testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestPrometheus(t *testing.T) { assert := assert.New(t) // Create a prometheus collector using the config file 'sample_config_prometheus.json' configFile, err := ioutil.ReadFile("config/sample_config_prometheus.json") containerHandler := containertest.NewMockContainerHandler("mockContainer") collector, err := NewPrometheusCollector("Prometheus", configFile, 100, containerHandler, http.DefaultClient) assert.NoError(err) assert.Equal("Prometheus", collector.name) assert.Equal("http://localhost:8080/metrics", collector.configFile.Endpoint.URL) tempServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { text := `# HELP go_gc_duration_seconds A summary of the GC invocation durations. # TYPE go_gc_duration_seconds summary go_gc_duration_seconds{quantile="0"} 5.8348000000000004e-05 go_gc_duration_seconds{quantile="1"} 0.000499764 go_gc_duration_seconds_sum 1.7560473e+07 go_gc_duration_seconds_count 2693 # HELP go_goroutines Number of goroutines that currently exist. # TYPE go_goroutines gauge go_goroutines 16 # HELP empty_metric A metric without any values # TYPE empty_metric counter # HELP metric_with_spaces_in_label A metric with spaces in a label. # TYPE metric_with_spaces_in_label gauge metric_with_spaces_in_label{name="Network Agent"} 72 # HELP metric_with_multiple_labels A metric with multiple labels. # TYPE metric_with_multiple_labels gauge metric_with_multiple_labels{label1="One", label2="Two", label3="Three"} 81 ` fmt.Fprintln(w, text) })) defer tempServer.Close() collector.configFile.Endpoint.URL = tempServer.URL var spec []v1.MetricSpec require.NotPanics(t, func() { spec = collector.GetSpec() }) assert.Len(spec, 4) specNames := make(map[string]struct{}, 3) for _, s := range spec { specNames[s.Name] = struct{}{} } expectedSpecNames := map[string]struct{}{ "go_gc_duration_seconds": {}, "go_goroutines": {}, "metric_with_spaces_in_label": {}, "metric_with_multiple_labels": {}, } assert.Equal(expectedSpecNames, specNames) metrics := map[string][]v1.MetricVal{} _, metrics, errMetric := collector.Collect(metrics) assert.NoError(errMetric) go_gc_duration := metrics["go_gc_duration_seconds"] assert.Equal(5.8348000000000004e-05, go_gc_duration[0].FloatValue) assert.Equal("__name__=go_gc_duration_seconds\xffquantile=0", go_gc_duration[0].Label) assert.Equal(0.000499764, go_gc_duration[1].FloatValue) assert.Equal("__name__=go_gc_duration_seconds\xffquantile=1", go_gc_duration[1].Label) go_gc_duration_sum := metrics["go_gc_duration_seconds_sum"] assert.Equal(1.7560473e+07, go_gc_duration_sum[0].FloatValue) assert.Equal("__name__=go_gc_duration_seconds_sum", go_gc_duration_sum[0].Label) go_gc_duration_count := metrics["go_gc_duration_seconds_count"] assert.Equal(2693, go_gc_duration_count[0].FloatValue) assert.Equal("__name__=go_gc_duration_seconds_count", go_gc_duration_count[0].Label) goRoutines := metrics["go_goroutines"] assert.Equal(16, goRoutines[0].FloatValue) assert.Equal("__name__=go_goroutines", goRoutines[0].Label) metricWithSpaces := metrics["metric_with_spaces_in_label"] assert.Equal(72, metricWithSpaces[0].FloatValue) assert.Equal("__name__=metric_with_spaces_in_label\xffname=Network Agent", metricWithSpaces[0].Label) metricWithMultipleLabels := metrics["metric_with_multiple_labels"] assert.Equal(81, metricWithMultipleLabels[0].FloatValue) assert.Equal("__name__=metric_with_multiple_labels\xfflabel1=One\xfflabel2=Two\xfflabel3=Three", metricWithMultipleLabels[0].Label) } func TestPrometheusEndpointConfig(t *testing.T) { assert := assert.New(t) //Create a prometheus collector using the config file 'sample_config_prometheus.json' configFile, err := ioutil.ReadFile("config/sample_config_prometheus_endpoint_config.json") containerHandler := containertest.NewMockContainerHandler("mockContainer") containerHandler.On("GetContainerIPAddress").Return( "222.222.222.222", ) collector, err := NewPrometheusCollector("Prometheus", configFile, 100, containerHandler, http.DefaultClient) assert.NoError(err) assert.Equal(collector.name, "Prometheus") assert.Equal(collector.configFile.Endpoint.URL, "http://222.222.222.222:8081/METRICS") } func TestPrometheusShortResponse(t *testing.T) { assert := assert.New(t) // Create a prometheus collector using the config file 'sample_config_prometheus.json' configFile, err := ioutil.ReadFile("config/sample_config_prometheus.json") containerHandler := containertest.NewMockContainerHandler("mockContainer") collector, err := NewPrometheusCollector("Prometheus", configFile, 100, containerHandler, http.DefaultClient) assert.NoError(err) assert.Equal(collector.name, "Prometheus") assert.Equal(collector.configFile.Endpoint.URL, "http://localhost:8080/metrics") tempServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { text := "# HELP empty_metric A metric without any values" fmt.Fprint(w, text) })) defer tempServer.Close() collector.configFile.Endpoint.URL = tempServer.URL assert.NotPanics(func() { collector.GetSpec() }) } func TestPrometheusMetricCountLimit(t *testing.T) { assert := assert.New(t) // Create a prometheus collector using the config file 'sample_config_prometheus.json' configFile, err := ioutil.ReadFile("config/sample_config_prometheus.json") containerHandler := containertest.NewMockContainerHandler("mockContainer") collector, err := NewPrometheusCollector("Prometheus", configFile, 10, containerHandler, http.DefaultClient) assert.NoError(err) assert.Equal(collector.name, "Prometheus") assert.Equal(collector.configFile.Endpoint.URL, "http://localhost:8080/metrics") tempServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { for i := 0; i < 30; i++ { fmt.Fprintf(w, "# HELP m%d Number of goroutines that currently exist.\n", i) fmt.Fprintf(w, "# TYPE m%d gauge\n", i) fmt.Fprintf(w, "m%d %d", i, i) } })) defer tempServer.Close() collector.configFile.Endpoint.URL = tempServer.URL metrics := map[string][]v1.MetricVal{} _, result, errMetric := collector.Collect(metrics) assert.Error(errMetric) assert.Equal(len(metrics), 0) assert.Nil(result) } func TestPrometheusFiltersMetrics(t *testing.T) { assert := assert.New(t) // Create a prometheus collector using the config file 'sample_config_prometheus_filtered.json' configFile, err := ioutil.ReadFile("config/sample_config_prometheus_filtered.json") containerHandler := containertest.NewMockContainerHandler("mockContainer") collector, err := NewPrometheusCollector("Prometheus", configFile, 100, containerHandler, http.DefaultClient) assert.NoError(err) assert.Equal(collector.name, "Prometheus") assert.Equal(collector.configFile.Endpoint.URL, "http://localhost:8080/metrics") tempServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { text := `# HELP go_gc_duration_seconds A summary of the GC invocation durations. # TYPE go_gc_duration_seconds summary go_gc_duration_seconds{quantile="0"} 5.8348000000000004e-05 go_gc_duration_seconds{quantile="1"} 0.000499764 go_gc_duration_seconds_sum 1.7560473e+07 go_gc_duration_seconds_count 2693 # HELP go_goroutines Number of goroutines that currently exist. # TYPE go_goroutines gauge go_goroutines 16 ` fmt.Fprintln(w, text) })) defer tempServer.Close() collector.configFile.Endpoint.URL = tempServer.URL metrics := map[string][]v1.MetricVal{} _, metrics, errMetric := collector.Collect(metrics) assert.NoError(errMetric) assert.Len(metrics, 1) goRoutines := metrics["go_goroutines"] assert.Equal(goRoutines[0].FloatValue, 16) } func TestPrometheusFiltersMetricsCountLimit(t *testing.T) { assert := assert.New(t) // Create a prometheus collector using the config file 'sample_config_prometheus_filtered.json' configFile, err := ioutil.ReadFile("config/sample_config_prometheus_filtered.json") containerHandler := containertest.NewMockContainerHandler("mockContainer") _, err = NewPrometheusCollector("Prometheus", configFile, 1, containerHandler, http.DefaultClient) assert.Error(err) } cadvisor-0.25.0/collector/types.go000066400000000000000000000034161306035727200171020ustar00rootroot00000000000000// Copyright 2015 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 collector import ( "time" "github.com/google/cadvisor/info/v1" ) // TODO(vmarmol): Export to a custom metrics type when that is available. // Metric collector. type Collector interface { // Collect metrics from this collector. // Returns the next time this collector should be collected from. // Next collection time is always returned, even when an error occurs. // A collection time of zero means no more collection. Collect(map[string][]v1.MetricVal) (time.Time, map[string][]v1.MetricVal, error) // Return spec for all metrics associated with this collector GetSpec() []v1.MetricSpec // Name of this collector. Name() string } // Manages and runs collectors. type CollectorManager interface { // Register a collector. RegisterCollector(collector Collector) error // Collect from collectors that are ready and return the next time // at which a collector will be ready to collect from. // Next collection time is always returned, even when an error occurs. // A collection time of zero means no more collection. Collect() (time.Time, map[string][]v1.MetricVal, error) // Get metric spec from all registered collectors. GetSpec() ([]v1.MetricSpec, error) } cadvisor-0.25.0/collector/util.go000066400000000000000000000021341306035727200167070ustar00rootroot00000000000000// Copyright 2016 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package collector import "github.com/google/cadvisor/container" func (endpointConfig *EndpointConfig) configure(containerHandler container.ContainerHandler) { //If the exact URL was not specified, generate it based on the ip address of the container. endpoint := endpointConfig if endpoint.URL == "" { ipAddress := containerHandler.GetContainerIPAddress() endpointConfig.URL = endpoint.URLConfig.Protocol + "://" + ipAddress + ":" + endpoint.URLConfig.Port.String() + endpoint.URLConfig.Path } } cadvisor-0.25.0/container/000077500000000000000000000000001306035727200153775ustar00rootroot00000000000000cadvisor-0.25.0/container/common/000077500000000000000000000000001306035727200166675ustar00rootroot00000000000000cadvisor-0.25.0/container/common/container_hints.go000066400000000000000000000036261306035727200224140ustar00rootroot00000000000000// 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. // Unmarshal's a Containers description json file. The json file contains // an array of ContainerHint structs, each with a container's id and networkInterface // This allows collecting stats about network interfaces configured outside docker // and lxc package common import ( "encoding/json" "flag" "io/ioutil" "os" ) var ArgContainerHints = flag.String("container_hints", "/etc/cadvisor/container_hints.json", "location of the container hints file") type containerHints struct { AllHosts []containerHint `json:"all_hosts,omitempty"` } type containerHint struct { FullName string `json:"full_path,omitempty"` NetworkInterface *networkInterface `json:"network_interface,omitempty"` Mounts []Mount `json:"mounts,omitempty"` } type Mount struct { HostDir string `json:"host_dir,omitempty"` ContainerDir string `json:"container_dir,omitempty"` } type networkInterface struct { VethHost string `json:"veth_host,omitempty"` VethChild string `json:"veth_child,omitempty"` } func GetContainerHintsFromFile(containerHintsFile string) (containerHints, error) { dat, err := ioutil.ReadFile(containerHintsFile) if os.IsNotExist(err) { return containerHints{}, nil } var cHints containerHints if err == nil { err = json.Unmarshal(dat, &cHints) } return cHints, err } cadvisor-0.25.0/container/common/container_hints_test.go000066400000000000000000000032101306035727200234400ustar00rootroot00000000000000// 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 common import ( "testing" ) func TestGetContainerHintsFromFile(t *testing.T) { cHints, err := GetContainerHintsFromFile("test_resources/container_hints.json") if err != nil { t.Fatalf("Error in unmarshalling: %s", err) } if cHints.AllHosts[0].NetworkInterface.VethHost != "veth24031eth1" && cHints.AllHosts[0].NetworkInterface.VethChild != "eth1" { t.Errorf("Cannot find network interface in %s", cHints) } correctMountDirs := [...]string{ "/var/run/nm-sdc1", "/var/run/nm-sdb3", "/var/run/nm-sda3", "/var/run/netns/root", "/var/run/openvswitch/db.sock", } if len(cHints.AllHosts[0].Mounts) == 0 { t.Errorf("Cannot find any mounts") } for i, mountDir := range cHints.AllHosts[0].Mounts { if correctMountDirs[i] != mountDir.HostDir { t.Errorf("Cannot find mount %s in %s", mountDir.HostDir, cHints) } } } func TestFileNotExist(t *testing.T) { _, err := GetContainerHintsFromFile("/file_does_not_exist.json") if err != nil { t.Fatalf("GetContainerHintsFromFile must not error for blank file: %s", err) } } cadvisor-0.25.0/container/common/fsHandler.go000066400000000000000000000071721306035727200211330ustar00rootroot00000000000000// Copyright 2015 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 Docker containers. package common import ( "fmt" "sync" "time" "github.com/google/cadvisor/fs" "github.com/golang/glog" ) type FsHandler interface { Start() Usage() FsUsage Stop() } type FsUsage struct { BaseUsageBytes uint64 TotalUsageBytes uint64 InodeUsage uint64 } type realFsHandler struct { sync.RWMutex lastUpdate time.Time usage FsUsage period time.Duration minPeriod time.Duration rootfs string extraDir string fsInfo fs.FsInfo // Tells the container to stop. stopChan chan struct{} } const ( longOp = time.Second timeout = 2 * time.Minute maxBackoffFactor = 20 ) const DefaultPeriod = time.Minute var _ FsHandler = &realFsHandler{} func NewFsHandler(period time.Duration, rootfs, extraDir string, fsInfo fs.FsInfo) FsHandler { return &realFsHandler{ lastUpdate: time.Time{}, usage: FsUsage{}, period: period, minPeriod: period, rootfs: rootfs, extraDir: extraDir, fsInfo: fsInfo, stopChan: make(chan struct{}, 1), } } func (fh *realFsHandler) update() error { var ( baseUsage, extraDirUsage, inodeUsage uint64 rootDiskErr, rootInodeErr, extraDiskErr error ) // TODO(vishh): Add support for external mounts. if fh.rootfs != "" { baseUsage, rootDiskErr = fh.fsInfo.GetDirDiskUsage(fh.rootfs, timeout) inodeUsage, rootInodeErr = fh.fsInfo.GetDirInodeUsage(fh.rootfs, timeout) } if fh.extraDir != "" { extraDirUsage, extraDiskErr = fh.fsInfo.GetDirDiskUsage(fh.extraDir, timeout) } // Wait to handle errors until after all operartions are run. // An error in one will not cause an early return, skipping others fh.Lock() defer fh.Unlock() fh.lastUpdate = time.Now() if rootDiskErr == nil && fh.rootfs != "" { fh.usage.InodeUsage = inodeUsage } if rootInodeErr == nil && fh.rootfs != "" { fh.usage.TotalUsageBytes = baseUsage + extraDirUsage } if extraDiskErr == nil && fh.extraDir != "" { fh.usage.BaseUsageBytes = baseUsage } // Combine errors into a single error to return if rootDiskErr != nil || rootInodeErr != nil || extraDiskErr != nil { return fmt.Errorf("rootDiskErr: %v, rootInodeErr: %v, extraDiskErr: %v", rootDiskErr, rootInodeErr, extraDiskErr) } return nil } func (fh *realFsHandler) trackUsage() { fh.update() for { select { case <-fh.stopChan: return case <-time.After(fh.period): start := time.Now() if err := fh.update(); err != nil { glog.Errorf("failed to collect filesystem stats - %v", err) fh.period = fh.period * 2 if fh.period > maxBackoffFactor*fh.minPeriod { fh.period = maxBackoffFactor * fh.minPeriod } } else { fh.period = fh.minPeriod } duration := time.Since(start) if duration > longOp { glog.V(2).Infof("du and find on following dirs took %v: %v", duration, []string{fh.rootfs, fh.extraDir}) } } } } func (fh *realFsHandler) Start() { go fh.trackUsage() } func (fh *realFsHandler) Stop() { close(fh.stopChan) } func (fh *realFsHandler) Usage() FsUsage { fh.RLock() defer fh.RUnlock() return fh.usage } cadvisor-0.25.0/container/common/helpers.go000066400000000000000000000140601306035727200206610ustar00rootroot00000000000000// Copyright 2016 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package common import ( "fmt" "io/ioutil" "os" "path" "strconv" "strings" "time" "github.com/google/cadvisor/container" info "github.com/google/cadvisor/info/v1" "github.com/google/cadvisor/utils" "github.com/golang/glog" ) func DebugInfo(watches map[string][]string) map[string][]string { out := make(map[string][]string) lines := make([]string, 0, len(watches)) for containerName, cgroupWatches := range watches { lines = append(lines, fmt.Sprintf("%s:", containerName)) for _, cg := range cgroupWatches { lines = append(lines, fmt.Sprintf("\t%s", cg)) } } out["Inotify watches"] = lines return out } func GetSpec(cgroupPaths map[string]string, machineInfoFactory info.MachineInfoFactory, hasNetwork, hasFilesystem bool) (info.ContainerSpec, error) { var spec info.ContainerSpec // Assume unified hierarchy containers. // Get the lowest creation time from all hierarchies as the container creation time. now := time.Now() lowestTime := now for _, cgroupPath := range cgroupPaths { // The modified time of the cgroup directory changes whenever a subcontainer is created. // eg. /docker will have creation time matching the creation of latest docker container. // Use clone_children as a workaround as it isn't usually modified. It is only likely changed // immediately after creating a container. cgroupPath = path.Join(cgroupPath, "cgroup.clone_children") fi, err := os.Stat(cgroupPath) if err == nil && fi.ModTime().Before(lowestTime) { lowestTime = fi.ModTime() } } if lowestTime != now { spec.CreationTime = lowestTime } // Get machine info. mi, err := machineInfoFactory.GetMachineInfo() if err != nil { return spec, err } // CPU. cpuRoot, ok := cgroupPaths["cpu"] if ok { if utils.FileExists(cpuRoot) { spec.HasCpu = true spec.Cpu.Limit = readUInt64(cpuRoot, "cpu.shares") spec.Cpu.Period = readUInt64(cpuRoot, "cpu.cfs_period_us") quota := readString(cpuRoot, "cpu.cfs_quota_us") if quota != "" && quota != "-1" { val, err := strconv.ParseUint(quota, 10, 64) if err != nil { glog.Errorf("GetSpec: Failed to parse CPUQuota from %q: %s", path.Join(cpuRoot, "cpu.cfs_quota_us"), err) } spec.Cpu.Quota = val } } } // Cpu Mask. // This will fail for non-unified hierarchies. We'll return the whole machine mask in that case. cpusetRoot, ok := cgroupPaths["cpuset"] if ok { if utils.FileExists(cpusetRoot) { spec.HasCpu = true mask := readString(cpusetRoot, "cpuset.cpus") spec.Cpu.Mask = utils.FixCpuMask(mask, mi.NumCores) } } // Memory memoryRoot, ok := cgroupPaths["memory"] if ok { if utils.FileExists(memoryRoot) { spec.HasMemory = true spec.Memory.Limit = readUInt64(memoryRoot, "memory.limit_in_bytes") spec.Memory.SwapLimit = readUInt64(memoryRoot, "memory.memsw.limit_in_bytes") spec.Memory.Reservation = readUInt64(memoryRoot, "memory.soft_limit_in_bytes") } } spec.HasNetwork = hasNetwork spec.HasFilesystem = hasFilesystem if blkioRoot, ok := cgroupPaths["blkio"]; ok && utils.FileExists(blkioRoot) { spec.HasDiskIo = true } return spec, nil } func readString(dirpath string, file string) string { cgroupFile := path.Join(dirpath, file) // Ignore non-existent files if !utils.FileExists(cgroupFile) { return "" } // Read out, err := ioutil.ReadFile(cgroupFile) if err != nil { glog.Errorf("readString: Failed to read %q: %s", cgroupFile, err) return "" } return strings.TrimSpace(string(out)) } func readUInt64(dirpath string, file string) uint64 { out := readString(dirpath, file) if out == "" { return 0 } val, err := strconv.ParseUint(out, 10, 64) if err != nil { glog.Errorf("readUInt64: Failed to parse int %q from file %q: %s", out, path.Join(dirpath, file), err) return 0 } return val } // Lists all directories under "path" and outputs the results as children of "parent". func ListDirectories(dirpath string, parent string, recursive bool, output map[string]struct{}) error { // Ignore if this hierarchy does not exist. if !utils.FileExists(dirpath) { return nil } entries, err := ioutil.ReadDir(dirpath) if err != nil { return err } for _, entry := range entries { // We only grab directories. if entry.IsDir() { name := path.Join(parent, entry.Name()) output[name] = struct{}{} // List subcontainers if asked to. if recursive { err := ListDirectories(path.Join(dirpath, entry.Name()), name, true, output) if err != nil { return err } } } } return nil } func MakeCgroupPaths(mountPoints map[string]string, name string) map[string]string { cgroupPaths := make(map[string]string, len(mountPoints)) for key, val := range mountPoints { cgroupPaths[key] = path.Join(val, name) } return cgroupPaths } func CgroupExists(cgroupPaths map[string]string) bool { // If any cgroup exists, the container is still alive. for _, cgroupPath := range cgroupPaths { if utils.FileExists(cgroupPath) { return true } } return false } func ListContainers(name string, cgroupPaths map[string]string, listType container.ListType) ([]info.ContainerReference, error) { containers := make(map[string]struct{}) for _, cgroupPath := range cgroupPaths { err := ListDirectories(cgroupPath, name, listType == container.ListRecursive, containers) if err != nil { return nil, err } } // Make into container references. ret := make([]info.ContainerReference, 0, len(containers)) for cont := range containers { ret = append(ret, info.ContainerReference{ Name: cont, }) } return ret, nil } cadvisor-0.25.0/container/common/inotify_watcher.go000066400000000000000000000067271306035727200224300ustar00rootroot00000000000000// Copyright 2015 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 common import ( "sync" "golang.org/x/exp/inotify" ) // Watcher for container-related inotify events in the cgroup hierarchy. // // Implementation is thread-safe. type InotifyWatcher struct { // Underlying inotify watcher. watcher *inotify.Watcher // Map of containers being watched to cgroup paths watched for that container. containersWatched map[string]map[string]bool // Lock for all datastructure access. lock sync.Mutex } func NewInotifyWatcher() (*InotifyWatcher, error) { w, err := inotify.NewWatcher() if err != nil { return nil, err } return &InotifyWatcher{ watcher: w, containersWatched: make(map[string]map[string]bool), }, nil } // Add a watch to the specified directory. Returns if the container was already being watched. func (iw *InotifyWatcher) AddWatch(containerName, dir string) (bool, error) { iw.lock.Lock() defer iw.lock.Unlock() cgroupsWatched, alreadyWatched := iw.containersWatched[containerName] // Register an inotify notification. if !cgroupsWatched[dir] { err := iw.watcher.AddWatch(dir, inotify.IN_CREATE|inotify.IN_DELETE|inotify.IN_MOVE) if err != nil { return alreadyWatched, err } if cgroupsWatched == nil { cgroupsWatched = make(map[string]bool) } cgroupsWatched[dir] = true } // Record our watching of the container. if !alreadyWatched { iw.containersWatched[containerName] = cgroupsWatched } return alreadyWatched, nil } // Remove watch from the specified directory. Returns if this was the last watch on the specified container. func (iw *InotifyWatcher) RemoveWatch(containerName, dir string) (bool, error) { iw.lock.Lock() defer iw.lock.Unlock() // If we don't have a watch registed for this, just return. cgroupsWatched, ok := iw.containersWatched[containerName] if !ok { return false, nil } // Remove the inotify watch if it exists. if cgroupsWatched[dir] { err := iw.watcher.RemoveWatch(dir) if err != nil { return false, nil } delete(cgroupsWatched, dir) } // Remove the record if this is the last watch. if len(cgroupsWatched) == 0 { delete(iw.containersWatched, containerName) return true, nil } return false, nil } // Errors are returned on this channel. func (iw *InotifyWatcher) Error() chan error { return iw.watcher.Error } // Events are returned on this channel. func (iw *InotifyWatcher) Event() chan *inotify.Event { return iw.watcher.Event } // Closes the inotify watcher. func (iw *InotifyWatcher) Close() error { return iw.watcher.Close() } // Returns a map of containers to the cgroup paths being watched. func (iw *InotifyWatcher) GetWatches() map[string][]string { out := make(map[string][]string, len(iw.containersWatched)) for k, v := range iw.containersWatched { out[k] = mapToSlice(v) } return out } func mapToSlice(m map[string]bool) []string { out := make([]string, 0, len(m)) for k := range m { out = append(out, k) } return out } cadvisor-0.25.0/container/common/test_resources/000077500000000000000000000000001306035727200217405ustar00rootroot00000000000000cadvisor-0.25.0/container/common/test_resources/container_hints.json000066400000000000000000000020311306035727200260160ustar00rootroot00000000000000{ "name": "Container Hints", "description": "Container hints file", "all_hosts": [ { "network_interface": { "veth_child": "eth1", "veth_host": "veth24031eth1" }, "mounts": [ { "host_dir": "/var/run/nm-sdc1", "container_dir": "/var/run/nm-sdc1", "permission": "rw" }, { "host_dir": "/var/run/nm-sdb3", "container_dir": "/var/run/nm-sdb3", "permission": "rw" }, { "host_dir": "/var/run/nm-sda3", "container_dir": "/var/run/nm-sda3", "permission": "rw" }, { "host_dir": "/var/run/netns/root", "container_dir": "/var/run/netns/root", "permission": "ro" }, { "host_dir": "/var/run/openvswitch/db.sock", "container_dir": "/var/run/openvswitch/db.sock", "permission": "rw" } ], "full_path": "18a4585950db428e4d5a65c216a5d708d241254709626f4cb300ee963fb4b144" } ] } cadvisor-0.25.0/container/container.go000066400000000000000000000044251306035727200177150ustar00rootroot00000000000000// Copyright 2014 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Package container defines types for sub-container events and also // defines an interface for container operation handlers. package container import info "github.com/google/cadvisor/info/v1" // ListType describes whether listing should be just for a // specific container or performed recursively. type ListType int const ( ListSelf ListType = iota ListRecursive ) type ContainerType int const ( ContainerTypeRaw ContainerType = iota ContainerTypeDocker ContainerTypeRkt ContainerTypeSystemd ) // Interface for container operation handlers. type ContainerHandler interface { // Returns the ContainerReference ContainerReference() (info.ContainerReference, error) // Returns container's isolation spec. GetSpec() (info.ContainerSpec, error) // Returns the current stats values of the container. GetStats() (*info.ContainerStats, error) // Returns the subcontainers of this container. ListContainers(listType ListType) ([]info.ContainerReference, error) // Returns the processes inside this container. ListProcesses(listType ListType) ([]int, error) // Returns absolute cgroup path for the requested resource. GetCgroupPath(resource string) (string, error) // Returns container labels, if available. GetContainerLabels() map[string]string // Returns the container's ip address, if available GetContainerIPAddress() string // Returns whether the container still exists. Exists() bool // Cleanup frees up any resources being held like fds or go routines, etc. Cleanup() // Start starts any necessary background goroutines - must be cleaned up in Cleanup(). // It is expected that most implementations will be a no-op. Start() // Type of handler Type() ContainerType } cadvisor-0.25.0/container/docker/000077500000000000000000000000001306035727200166465ustar00rootroot00000000000000cadvisor-0.25.0/container/docker/client.go000066400000000000000000000021001306035727200204440ustar00rootroot00000000000000// Copyright 2015 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 /validate content. // Validates cadvisor dependencies - kernel, os, docker setup. package docker import ( "sync" dclient "github.com/docker/engine-api/client" ) var ( dockerClient *dclient.Client dockerClientErr error dockerClientOnce sync.Once ) func Client() (*dclient.Client, error) { dockerClientOnce.Do(func() { dockerClient, dockerClientErr = dclient.NewClient(*ArgDockerEndpoint, "", nil, nil) }) return dockerClient, dockerClientErr } cadvisor-0.25.0/container/docker/docker.go000066400000000000000000000115551306035727200204530ustar00rootroot00000000000000// Copyright 2016 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Provides global docker information. package docker import ( "fmt" "strconv" "strings" dockertypes "github.com/docker/engine-api/types" "golang.org/x/net/context" "github.com/google/cadvisor/info/v1" "github.com/google/cadvisor/machine" ) func Status() (v1.DockerStatus, error) { client, err := Client() if err != nil { return v1.DockerStatus{}, fmt.Errorf("unable to communicate with docker daemon: %v", err) } dockerInfo, err := client.Info(context.Background()) if err != nil { return v1.DockerStatus{}, err } out := v1.DockerStatus{} out.Version = VersionString() out.KernelVersion = machine.KernelVersion() out.OS = dockerInfo.OperatingSystem out.Hostname = dockerInfo.Name out.RootDir = dockerInfo.DockerRootDir out.Driver = dockerInfo.Driver out.ExecDriver = dockerInfo.ExecutionDriver out.NumImages = dockerInfo.Images out.NumContainers = dockerInfo.Containers out.DriverStatus = make(map[string]string, len(dockerInfo.DriverStatus)) for _, v := range dockerInfo.DriverStatus { out.DriverStatus[v[0]] = v[1] } return out, nil } func Images() ([]v1.DockerImage, error) { client, err := Client() if err != nil { return nil, fmt.Errorf("unable to communicate with docker daemon: %v", err) } images, err := client.ImageList(context.Background(), dockertypes.ImageListOptions{All: false}) if err != nil { return nil, err } out := []v1.DockerImage{} const unknownTag = ":" for _, image := range images { if len(image.RepoTags) == 1 && image.RepoTags[0] == unknownTag { // images with repo or tags are uninteresting. continue } di := v1.DockerImage{ ID: image.ID, RepoTags: image.RepoTags, Created: image.Created, VirtualSize: image.VirtualSize, Size: image.Size, } out = append(out, di) } return out, nil } // Checks whether the dockerInfo reflects a valid docker setup, and returns it if it does, or an // error otherwise. func ValidateInfo() (*dockertypes.Info, error) { client, err := Client() if err != nil { return nil, fmt.Errorf("unable to communicate with docker daemon: %v", err) } dockerInfo, err := client.Info(context.Background()) if err != nil { return nil, fmt.Errorf("failed to detect Docker info: %v", err) } // Fall back to version API if ServerVersion is not set in info. if dockerInfo.ServerVersion == "" { version, err := client.ServerVersion(context.Background()) if err != nil { return nil, fmt.Errorf("unable to get docker version: %v", err) } dockerInfo.ServerVersion = version.Version } version, err := parseDockerVersion(dockerInfo.ServerVersion) if err != nil { return nil, err } if version[0] < 1 { return nil, fmt.Errorf("cAdvisor requires docker version %v or above but we have found version %v reported as %q", []int{1, 0, 0}, version, dockerInfo.ServerVersion) } // Check that the libcontainer execdriver is used if the version is < 1.11 // (execution drivers are no longer supported as of 1.11). if version[0] <= 1 && version[1] <= 10 && !strings.HasPrefix(dockerInfo.ExecutionDriver, "native") { return nil, fmt.Errorf("docker found, but not using native exec driver") } if dockerInfo.Driver == "" { return nil, fmt.Errorf("failed to find docker storage driver") } return &dockerInfo, nil } func Version() ([]int, error) { return parseDockerVersion(VersionString()) } func VersionString() string { docker_version := "Unknown" client, err := Client() if err == nil { version, err := client.ServerVersion(context.Background()) if err == nil { docker_version = version.Version } } return docker_version } // TODO: switch to a semantic versioning library. func parseDockerVersion(full_version_string string) ([]int, error) { 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 } cadvisor-0.25.0/container/docker/factory.go000066400000000000000000000226001306035727200206440ustar00rootroot00000000000000// 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" "path" "regexp" "strconv" "strings" "sync" "github.com/blang/semver" dockertypes "github.com/docker/engine-api/types" "github.com/google/cadvisor/container" "github.com/google/cadvisor/container/libcontainer" "github.com/google/cadvisor/devicemapper" "github.com/google/cadvisor/fs" info "github.com/google/cadvisor/info/v1" "github.com/google/cadvisor/machine" "github.com/google/cadvisor/manager/watcher" dockerutil "github.com/google/cadvisor/utils/docker" docker "github.com/docker/engine-api/client" "github.com/golang/glog" "golang.org/x/net/context" ) var ArgDockerEndpoint = flag.String("docker", "unix:///var/run/docker.sock", "docker endpoint") // The namespace under which Docker aliases are unique. const DockerNamespace = "docker" // Regexp that identifies docker cgroups, containers started with // --cgroup-parent have another prefix than 'docker' var dockerCgroupRegexp = regexp.MustCompile(`([a-z0-9]{64})`) var dockerEnvWhitelist = flag.String("docker_env_metadata_whitelist", "", "a comma-separated list of environment variable keys that needs to be collected for docker containers") var ( // Basepath to all container specific information that libcontainer stores. dockerRootDir string dockerRootDirFlag = flag.String("docker_root", "/var/lib/docker", "DEPRECATED: docker root is read from docker info (this is a fallback, default: /var/lib/docker)") dockerRootDirOnce sync.Once // flag that controls globally disabling thin_ls pending future enhancements. // in production, it has been found that thin_ls makes excessive use of iops. // in an iops restricted environment, usage of thin_ls must be controlled via blkio. // pending that enhancement, disable its usage. disableThinLs = true ) func RootDir() string { dockerRootDirOnce.Do(func() { status, err := Status() if err == nil && status.RootDir != "" { dockerRootDir = status.RootDir } else { dockerRootDir = *dockerRootDirFlag } }) return dockerRootDir } type storageDriver string const ( devicemapperStorageDriver storageDriver = "devicemapper" aufsStorageDriver storageDriver = "aufs" overlayStorageDriver storageDriver = "overlay" zfsStorageDriver storageDriver = "zfs" ) type dockerFactory struct { machineInfoFactory info.MachineInfoFactory storageDriver storageDriver storageDir string client *docker.Client // Information about the mounted cgroup subsystems. cgroupSubsystems libcontainer.CgroupSubsystems // Information about mounted filesystems. fsInfo fs.FsInfo dockerVersion []int ignoreMetrics container.MetricSet thinPoolWatcher *devicemapper.ThinPoolWatcher } func (self *dockerFactory) String() string { return DockerNamespace } func (self *dockerFactory) NewContainerHandler(name string, inHostNamespace bool) (handler container.ContainerHandler, err error) { client, err := Client() if err != nil { return } metadataEnvs := strings.Split(*dockerEnvWhitelist, ",") handler, err = newDockerContainerHandler( client, name, self.machineInfoFactory, self.fsInfo, self.storageDriver, self.storageDir, &self.cgroupSubsystems, inHostNamespace, metadataEnvs, self.dockerVersion, self.ignoreMetrics, self.thinPoolWatcher, ) return } // Returns the Docker ID from the full container name. func ContainerNameToDockerId(name string) string { id := path.Base(name) if matches := dockerCgroupRegexp.FindStringSubmatch(id); matches != nil { return matches[1] } return id } // isContainerName returns true if the cgroup with associated name // corresponds to a docker container. func isContainerName(name string) bool { // always ignore .mount cgroup even if associated with docker and delegate to systemd if strings.HasSuffix(name, ".mount") { return false } return dockerCgroupRegexp.MatchString(path.Base(name)) } // Docker handles all containers under /docker func (self *dockerFactory) CanHandleAndAccept(name string) (bool, bool, error) { // if the container is not associated with docker, we can't handle it or accept it. if !isContainerName(name) { return false, false, nil } // Check if the container is known to docker and it is active. id := ContainerNameToDockerId(name) // We assume that if Inspect fails then the container is not known to docker. ctnr, err := self.client.ContainerInspect(context.Background(), id) if err != nil || !ctnr.State.Running { return false, true, fmt.Errorf("error inspecting container: %v", err) } return true, true, nil } func (self *dockerFactory) DebugInfo() map[string][]string { return map[string][]string{} } var ( version_regexp_string = `(\d+)\.(\d+)\.(\d+)` version_re = regexp.MustCompile(version_regexp_string) ) func startThinPoolWatcher(dockerInfo *dockertypes.Info) (*devicemapper.ThinPoolWatcher, error) { _, err := devicemapper.ThinLsBinaryPresent() if err != nil { return nil, err } if err := ensureThinLsKernelVersion(machine.KernelVersion()); err != nil { return nil, err } if disableThinLs { return nil, fmt.Errorf("usage of thin_ls is disabled to preserve iops") } dockerThinPoolName, err := dockerutil.DockerThinPoolName(*dockerInfo) if err != nil { return nil, err } dockerMetadataDevice, err := dockerutil.DockerMetadataDevice(*dockerInfo) if err != nil { return nil, err } thinPoolWatcher, err := devicemapper.NewThinPoolWatcher(dockerThinPoolName, dockerMetadataDevice) if err != nil { return nil, err } go thinPoolWatcher.Start() return thinPoolWatcher, nil } func ensureThinLsKernelVersion(kernelVersion string) error { // kernel 4.4.0 has the proper bug fixes to allow thin_ls to work without corrupting the thin pool minKernelVersion := semver.MustParse("4.4.0") // RHEL 7 kernel 3.10.0 release >= 366 has the proper bug fixes backported from 4.4.0 to allow // thin_ls to work without corrupting the thin pool minRhel7KernelVersion := semver.MustParse("3.10.0") matches := version_re.FindStringSubmatch(kernelVersion) if len(matches) < 4 { return fmt.Errorf("error parsing kernel version: %q is not a semver", kernelVersion) } sem, err := semver.Make(matches[0]) if err != nil { return err } if sem.GTE(minKernelVersion) { // kernel 4.4+ - good return nil } // Certain RHEL/Centos 7.x kernels have a backport to fix the corruption bug if !strings.Contains(kernelVersion, ".el7") { // not a RHEL 7.x kernel - won't work return fmt.Errorf("kernel version 4.4.0 or later is required to use thin_ls - you have %q", kernelVersion) } // RHEL/Centos 7.x from here on if sem.Major != 3 { // only 3.x kernels *may* work correctly return fmt.Errorf("RHEL/Centos 7.x kernel version 3.10.0-366 or later is required to use thin_ls - you have %q", kernelVersion) } if sem.GT(minRhel7KernelVersion) { // 3.10.1+ - good return nil } if sem.EQ(minRhel7KernelVersion) { // need to check release releaseRE := regexp.MustCompile(`^[^-]+-([0-9]+)\.`) releaseMatches := releaseRE.FindStringSubmatch(kernelVersion) if len(releaseMatches) != 2 { return fmt.Errorf("unable to determine RHEL/Centos 7.x kernel release from %q", kernelVersion) } release, err := strconv.Atoi(releaseMatches[1]) if err != nil { return fmt.Errorf("error parsing release %q: %v", releaseMatches[1], err) } if release >= 366 { return nil } } return fmt.Errorf("RHEL/Centos 7.x kernel version 3.10.0-366 or later is required to use thin_ls - you have %q", kernelVersion) } // Register root container before running this function! func Register(factory info.MachineInfoFactory, fsInfo fs.FsInfo, ignoreMetrics container.MetricSet) error { client, err := Client() if err != nil { return fmt.Errorf("unable to communicate with docker daemon: %v", err) } dockerInfo, err := ValidateInfo() if err != nil { return fmt.Errorf("failed to validate Docker info: %v", err) } // Version already validated above, assume no error here. dockerVersion, _ := parseDockerVersion(dockerInfo.ServerVersion) cgroupSubsystems, err := libcontainer.GetCgroupSubsystems() if err != nil { return fmt.Errorf("failed to get cgroup subsystems: %v", err) } var thinPoolWatcher *devicemapper.ThinPoolWatcher if storageDriver(dockerInfo.Driver) == devicemapperStorageDriver { thinPoolWatcher, err = startThinPoolWatcher(dockerInfo) if err != nil { glog.Errorf("devicemapper filesystem stats will not be reported: %v", err) } } glog.Infof("Registering Docker factory") f := &dockerFactory{ cgroupSubsystems: cgroupSubsystems, client: client, dockerVersion: dockerVersion, fsInfo: fsInfo, machineInfoFactory: factory, storageDriver: storageDriver(dockerInfo.Driver), storageDir: RootDir(), ignoreMetrics: ignoreMetrics, thinPoolWatcher: thinPoolWatcher, } container.RegisterContainerHandlerFactory(f, []watcher.ContainerWatchSource{watcher.Raw}) return nil } cadvisor-0.25.0/container/docker/factory_test.go000066400000000000000000000051671306035727200217140ustar00rootroot00000000000000// Copyright 2016 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package docker import "testing" func TestEnsureThinLsKernelVersion(t *testing.T) { tests := []struct { version string expectedError string }{ {"4.4.0-31-generic", ""}, {"4.4.1", ""}, {"4.6.4-301.fc24.x86_64", ""}, {"3.10.0-327.22.2.el7.x86_64", `RHEL/Centos 7.x kernel version 3.10.0-366 or later is required to use thin_ls - you have "3.10.0-327.22.2.el7.x86_64"`}, {"3.10.0-366.el7.x86_64", ""}, {"3.10.0-366.el7_3.x86_64", ""}, {"3.10.0.el7.abc", `unable to determine RHEL/Centos 7.x kernel release from "3.10.0.el7.abc"`}, {"3.10.0-abc.el7.blarg", `unable to determine RHEL/Centos 7.x kernel release from "3.10.0-abc.el7.blarg"`}, {"3.10.0-367.el7.x86_64", ""}, {"3.10.0-366.x86_64", `kernel version 4.4.0 or later is required to use thin_ls - you have "3.10.0-366.x86_64"`}, {"3.10.1-1.el7.x86_64", ""}, {"2.0.36", `kernel version 4.4.0 or later is required to use thin_ls - you have "2.0.36"`}, {"2.1", `error parsing kernel version: "2.1" is not a semver`}, } for _, test := range tests { err := ensureThinLsKernelVersion(test.version) if err != nil { if len(test.expectedError) == 0 { t.Errorf("%s: expected no error, got %v", test.version, err) } else if err.Error() != test.expectedError { t.Errorf("%s: expected error %v, got %v", test.version, test.expectedError, err) } } else if err == nil && len(test.expectedError) > 0 { t.Errorf("%s: expected error %v", test.version, test.expectedError) } } } func TestIsContainerName(t *testing.T) { tests := []struct { name string expected bool }{ { name: "/system.slice/var-lib-docker-overlay-9f086b233ab7c786bf8b40b164680b658a8f00e94323868e288d6ce20bc92193-merged.mount", expected: false, }, { name: "/system.slice/docker-72e5a5ff5eef3c4222a6551b992b9360a99122f77d2229783f0ee0946dfd800e.scope", expected: true, }, } for _, test := range tests { if actual := isContainerName(test.name); actual != test.expected { t.Errorf("%s: expected: %v, actual: %v", test.name, test.expected, actual) } } } cadvisor-0.25.0/container/docker/handler.go000066400000000000000000000336601306035727200206220ustar00rootroot00000000000000// 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 Docker containers. package docker import ( "fmt" "io/ioutil" "path" "strings" "time" "github.com/google/cadvisor/container" "github.com/google/cadvisor/container/common" containerlibcontainer "github.com/google/cadvisor/container/libcontainer" "github.com/google/cadvisor/devicemapper" "github.com/google/cadvisor/fs" info "github.com/google/cadvisor/info/v1" dockerutil "github.com/google/cadvisor/utils/docker" docker "github.com/docker/engine-api/client" dockercontainer "github.com/docker/engine-api/types/container" "github.com/golang/glog" "github.com/opencontainers/runc/libcontainer/cgroups" cgroupfs "github.com/opencontainers/runc/libcontainer/cgroups/fs" libcontainerconfigs "github.com/opencontainers/runc/libcontainer/configs" "golang.org/x/net/context" ) const ( // The read write layers exist here. aufsRWLayer = "diff" // Path to the directory where docker stores log files if the json logging driver is enabled. pathToContainersDir = "containers" ) type dockerContainerHandler struct { client *docker.Client name string id string aliases []string machineInfoFactory info.MachineInfoFactory // Absolute path to the cgroup hierarchies of this container. // (e.g.: "cpu" -> "/sys/fs/cgroup/cpu/test") cgroupPaths map[string]string // Manager of this container's cgroups. cgroupManager cgroups.Manager // the docker storage driver storageDriver storageDriver fsInfo fs.FsInfo rootfsStorageDir string // devicemapper state // the devicemapper poolname poolName string // the devicemapper device id for the container deviceID string // Time at which this container was created. creationTime time.Time // Metadata associated with the container. labels map[string]string envs map[string]string // The container PID used to switch namespaces as required pid int // Image name used for this container. image string // The host root FS to read rootFs string // The network mode of the container networkMode dockercontainer.NetworkMode // Filesystem handler. fsHandler common.FsHandler // The IP address of the container ipAddress string ignoreMetrics container.MetricSet // thin pool watcher thinPoolWatcher *devicemapper.ThinPoolWatcher } var _ container.ContainerHandler = &dockerContainerHandler{} func getRwLayerID(containerID, storageDir string, sd storageDriver, dockerVersion []int) (string, error) { const ( // Docker version >=1.10.0 have a randomized ID for the root fs of a container. randomizedRWLayerMinorVersion = 10 rwLayerIDFile = "mount-id" ) if (dockerVersion[0] <= 1) && (dockerVersion[1] < randomizedRWLayerMinorVersion) { return containerID, nil } bytes, err := ioutil.ReadFile(path.Join(storageDir, "image", string(sd), "layerdb", "mounts", containerID, rwLayerIDFile)) if err != nil { return "", fmt.Errorf("failed to identify the read-write layer ID for container %q. - %v", containerID, err) } return string(bytes), err } // newDockerContainerHandler returns a new container.ContainerHandler func newDockerContainerHandler( client *docker.Client, name string, machineInfoFactory info.MachineInfoFactory, fsInfo fs.FsInfo, storageDriver storageDriver, storageDir string, cgroupSubsystems *containerlibcontainer.CgroupSubsystems, inHostNamespace bool, metadataEnvs []string, dockerVersion []int, ignoreMetrics container.MetricSet, thinPoolWatcher *devicemapper.ThinPoolWatcher, ) (container.ContainerHandler, error) { // Create the cgroup paths. cgroupPaths := make(map[string]string, len(cgroupSubsystems.MountPoints)) for key, val := range cgroupSubsystems.MountPoints { cgroupPaths[key] = path.Join(val, name) } // Generate the equivalent cgroup manager for this container. cgroupManager := &cgroupfs.Manager{ Cgroups: &libcontainerconfigs.Cgroup{ Name: name, }, Paths: cgroupPaths, } rootFs := "/" if !inHostNamespace { rootFs = "/rootfs" storageDir = path.Join(rootFs, storageDir) } id := ContainerNameToDockerId(name) // Add the Containers dir where the log files are stored. // FIXME: Give `otherStorageDir` a more descriptive name. otherStorageDir := path.Join(storageDir, pathToContainersDir, id) rwLayerID, err := getRwLayerID(id, storageDir, storageDriver, dockerVersion) if err != nil { return nil, err } // Determine the rootfs storage dir OR the pool name to determine the device var ( rootfsStorageDir string poolName string ) switch storageDriver { case aufsStorageDriver: rootfsStorageDir = path.Join(storageDir, string(aufsStorageDriver), aufsRWLayer, rwLayerID) case overlayStorageDriver: rootfsStorageDir = path.Join(storageDir, string(overlayStorageDriver), rwLayerID) case devicemapperStorageDriver: status, err := Status() if err != nil { return nil, fmt.Errorf("unable to determine docker status: %v", err) } poolName = status.DriverStatus[dockerutil.DriverStatusPoolName] } // TODO: extract object mother method handler := &dockerContainerHandler{ id: id, client: client, name: name, machineInfoFactory: machineInfoFactory, cgroupPaths: cgroupPaths, cgroupManager: cgroupManager, storageDriver: storageDriver, fsInfo: fsInfo, rootFs: rootFs, poolName: poolName, rootfsStorageDir: rootfsStorageDir, envs: make(map[string]string), ignoreMetrics: ignoreMetrics, thinPoolWatcher: thinPoolWatcher, } // We assume that if Inspect fails then the container is not known to docker. ctnr, err := client.ContainerInspect(context.Background(), id) if err != nil { return nil, fmt.Errorf("failed to inspect container %q: %v", id, err) } // Timestamp returned by Docker is in time.RFC3339Nano format. handler.creationTime, err = time.Parse(time.RFC3339Nano, ctnr.Created) if err != nil { // This should not happen, report the error just in case return nil, fmt.Errorf("failed to parse the create timestamp %q for container %q: %v", ctnr.Created, id, err) } handler.pid = ctnr.State.Pid // Add the name and bare ID as aliases of the container. handler.aliases = append(handler.aliases, strings.TrimPrefix(ctnr.Name, "/"), id) handler.labels = ctnr.Config.Labels handler.image = ctnr.Config.Image handler.networkMode = ctnr.HostConfig.NetworkMode handler.deviceID = ctnr.GraphDriver.Data["DeviceId"] // Obtain the IP address for the contianer. // If the NetworkMode starts with 'container:' then we need to use the IP address of the container specified. // This happens in cases such as kubernetes where the containers doesn't have an IP address itself and we need to use the pod's address ipAddress := ctnr.NetworkSettings.IPAddress networkMode := string(ctnr.HostConfig.NetworkMode) if ipAddress == "" && strings.HasPrefix(networkMode, "container:") { containerId := strings.TrimPrefix(networkMode, "container:") c, err := client.ContainerInspect(context.Background(), containerId) if err != nil { return nil, fmt.Errorf("failed to inspect container %q: %v", id, err) } ipAddress = c.NetworkSettings.IPAddress } handler.ipAddress = ipAddress if !ignoreMetrics.Has(container.DiskUsageMetrics) { handler.fsHandler = &dockerFsHandler{ fsHandler: common.NewFsHandler(common.DefaultPeriod, rootfsStorageDir, otherStorageDir, fsInfo), thinPoolWatcher: thinPoolWatcher, deviceID: handler.deviceID, } } // split env vars to get metadata map. for _, exposedEnv := range metadataEnvs { for _, envVar := range ctnr.Config.Env { if envVar != "" { splits := strings.SplitN(envVar, "=", 2) if len(splits) == 2 && splits[0] == exposedEnv { handler.envs[strings.ToLower(exposedEnv)] = splits[1] } } } } return handler, nil } // dockerFsHandler is a composite FsHandler implementation the incorporates // the common fs handler and a devicemapper ThinPoolWatcher. type dockerFsHandler struct { fsHandler common.FsHandler // thinPoolWatcher is the devicemapper thin pool watcher thinPoolWatcher *devicemapper.ThinPoolWatcher // deviceID is the id of the container's fs device deviceID string } var _ common.FsHandler = &dockerFsHandler{} func (h *dockerFsHandler) Start() { h.fsHandler.Start() } func (h *dockerFsHandler) Stop() { h.fsHandler.Stop() } func (h *dockerFsHandler) Usage() common.FsUsage { usage := h.fsHandler.Usage() // When devicemapper is the storage driver, the base usage of the container comes from the thin pool. // We still need the result of the fsHandler for any extra storage associated with the container. // To correctly factor in the thin pool usage, we should: // * Usage the thin pool usage as the base usage // * Calculate the overall usage by adding the overall usage from the fs handler to the thin pool usage if h.thinPoolWatcher != nil { thinPoolUsage, err := h.thinPoolWatcher.GetUsage(h.deviceID) if err != nil { // TODO: ideally we should keep track of how many times we failed to get the usage for this // device vs how many refreshes of the cache there have been, and display an error e.g. if we've // had at least 1 refresh and we still can't find the device. glog.V(5).Infof("unable to get fs usage from thin pool for device %s: %v", h.deviceID, err) } else { usage.BaseUsageBytes = thinPoolUsage usage.TotalUsageBytes += thinPoolUsage } } return usage } func (self *dockerContainerHandler) Start() { if self.fsHandler != nil { self.fsHandler.Start() } } func (self *dockerContainerHandler) Cleanup() { if self.fsHandler != nil { self.fsHandler.Stop() } } func (self *dockerContainerHandler) ContainerReference() (info.ContainerReference, error) { return info.ContainerReference{ Id: self.id, Name: self.name, Aliases: self.aliases, Namespace: DockerNamespace, Labels: self.labels, }, nil } func (self *dockerContainerHandler) needNet() bool { if !self.ignoreMetrics.Has(container.NetworkUsageMetrics) { return !self.networkMode.IsContainer() } return false } func (self *dockerContainerHandler) GetSpec() (info.ContainerSpec, error) { hasFilesystem := !self.ignoreMetrics.Has(container.DiskUsageMetrics) spec, err := common.GetSpec(self.cgroupPaths, self.machineInfoFactory, self.needNet(), hasFilesystem) spec.Labels = self.labels spec.Envs = self.envs spec.Image = self.image return spec, err } func (self *dockerContainerHandler) getFsStats(stats *info.ContainerStats) error { if self.ignoreMetrics.Has(container.DiskUsageMetrics) { return nil } var device string switch self.storageDriver { case devicemapperStorageDriver: // Device has to be the pool name to correlate with the device name as // set in the machine info filesystems. device = self.poolName case aufsStorageDriver, overlayStorageDriver, zfsStorageDriver: deviceInfo, err := self.fsInfo.GetDirFsDevice(self.rootfsStorageDir) if err != nil { return fmt.Errorf("unable to determine device info for dir: %v: %v", self.rootfsStorageDir, err) } device = deviceInfo.Device default: return nil } mi, err := self.machineInfoFactory.GetMachineInfo() if err != nil { return err } var ( limit uint64 fsType string ) // Docker does not impose any filesystem limits for containers. So use capacity as limit. for _, fs := range mi.Filesystems { if fs.Device == device { limit = fs.Capacity fsType = fs.Type break } } fsStat := info.FsStats{Device: device, Type: fsType, Limit: limit} usage := self.fsHandler.Usage() fsStat.BaseUsage = usage.BaseUsageBytes fsStat.Usage = usage.TotalUsageBytes fsStat.Inodes = usage.InodeUsage stats.Filesystem = append(stats.Filesystem, fsStat) return nil } // TODO(vmarmol): Get from libcontainer API instead of cgroup manager when we don't have to support older Dockers. func (self *dockerContainerHandler) GetStats() (*info.ContainerStats, error) { stats, err := containerlibcontainer.GetStats(self.cgroupManager, self.rootFs, self.pid, self.ignoreMetrics) if err != nil { return stats, err } // Clean up stats for containers that don't have their own network - this // includes containers running in Kubernetes pods that use the network of the // infrastructure container. This stops metrics being reported multiple times // for each container in a pod. if !self.needNet() { stats.Network = info.NetworkStats{} } // Get filesystem stats. err = self.getFsStats(stats) if err != nil { return stats, err } return stats, nil } func (self *dockerContainerHandler) ListContainers(listType container.ListType) ([]info.ContainerReference, error) { // No-op for Docker driver. return []info.ContainerReference{}, nil } func (self *dockerContainerHandler) GetCgroupPath(resource string) (string, error) { path, ok := self.cgroupPaths[resource] if !ok { return "", fmt.Errorf("could not find path for resource %q for container %q\n", resource, self.name) } return path, nil } func (self *dockerContainerHandler) GetContainerLabels() map[string]string { return self.labels } func (self *dockerContainerHandler) GetContainerIPAddress() string { return self.ipAddress } func (self *dockerContainerHandler) ListProcesses(listType container.ListType) ([]int, error) { return containerlibcontainer.GetProcesses(self.cgroupManager) } func (self *dockerContainerHandler) Exists() bool { return common.CgroupExists(self.cgroupPaths) } func (self *dockerContainerHandler) Type() container.ContainerType { return container.ContainerTypeDocker } cadvisor-0.25.0/container/docker/handler_test.go000066400000000000000000000031041306035727200216470ustar00rootroot00000000000000// 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 Docker containers. package docker import ( "io/ioutil" "os" "path" "testing" "github.com/stretchr/testify/assert" ) func TestStorageDirDetectionWithOldVersions(t *testing.T) { as := assert.New(t) rwLayer, err := getRwLayerID("abcd", "/", aufsStorageDriver, []int{1, 9, 0}) as.Nil(err) as.Equal(rwLayer, "abcd") } func TestStorageDirDetectionWithNewVersions(t *testing.T) { as := assert.New(t) testDir, err := ioutil.TempDir("", "") as.Nil(err) containerID := "abcd" randomizedID := "xyz" randomIDPath := path.Join(testDir, "image/aufs/layerdb/mounts/", containerID) as.Nil(os.MkdirAll(randomIDPath, os.ModePerm)) as.Nil(ioutil.WriteFile(path.Join(randomIDPath, "mount-id"), []byte(randomizedID), os.ModePerm)) rwLayer, err := getRwLayerID(containerID, testDir, "aufs", []int{1, 10, 0}) as.Nil(err) as.Equal(rwLayer, randomizedID) rwLayer, err = getRwLayerID(containerID, testDir, "aufs", []int{1, 10, 0}) as.Nil(err) as.Equal(rwLayer, randomizedID) } cadvisor-0.25.0/container/factory.go000066400000000000000000000104661306035727200174040ustar00rootroot00000000000000// 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" "sync" "github.com/google/cadvisor/manager/watcher" "github.com/golang/glog" ) type ContainerHandlerFactory interface { // Create a new ContainerHandler using this factory. CanHandleAndAccept() must have returned true. NewContainerHandler(name string, inHostNamespace bool) (c ContainerHandler, err error) // Returns whether this factory can handle and accept the specified container. CanHandleAndAccept(name string) (handle bool, accept bool, err error) // Name of the factory. String() string // Returns debugging information. Map of lines per category. DebugInfo() map[string][]string } // MetricKind represents the kind of metrics that cAdvisor exposes. type MetricKind string const ( CpuUsageMetrics MetricKind = "cpu" MemoryUsageMetrics MetricKind = "memory" CpuLoadMetrics MetricKind = "cpuLoad" DiskIOMetrics MetricKind = "diskIO" DiskUsageMetrics MetricKind = "disk" NetworkUsageMetrics MetricKind = "network" NetworkTcpUsageMetrics MetricKind = "tcp" AppMetrics MetricKind = "app" ) func (mk MetricKind) String() string { return string(mk) } type MetricSet map[MetricKind]struct{} func (ms MetricSet) Has(mk MetricKind) bool { _, exists := ms[mk] return exists } func (ms MetricSet) Add(mk MetricKind) { ms[mk] = struct{}{} } // TODO(vmarmol): Consider not making this global. // Global list of factories. var ( factories = map[watcher.ContainerWatchSource][]ContainerHandlerFactory{} factoriesLock sync.RWMutex ) // Register a ContainerHandlerFactory. These should be registered from least general to most general // as they will be asked in order whether they can handle a particular container. func RegisterContainerHandlerFactory(factory ContainerHandlerFactory, watchTypes []watcher.ContainerWatchSource) { factoriesLock.Lock() defer factoriesLock.Unlock() for _, watchType := range watchTypes { factories[watchType] = append(factories[watchType], factory) } } // Returns whether there are any container handler factories registered. func HasFactories() bool { factoriesLock.Lock() defer factoriesLock.Unlock() return len(factories) != 0 } // Create a new ContainerHandler for the specified container. func NewContainerHandler(name string, watchType watcher.ContainerWatchSource, inHostNamespace bool) (ContainerHandler, bool, error) { factoriesLock.RLock() defer factoriesLock.RUnlock() // Create the ContainerHandler with the first factory that supports it. for _, factory := range factories[watchType] { canHandle, canAccept, err := factory.CanHandleAndAccept(name) if err != nil { glog.V(4).Infof("Error trying to work out if we can handle %s: %v", name, err) } if canHandle { if !canAccept { glog.V(3).Infof("Factory %q can handle container %q, but ignoring.", factory, name) return nil, false, nil } glog.V(3).Infof("Using factory %q for container %q", factory, name) handle, err := factory.NewContainerHandler(name, inHostNamespace) return handle, canAccept, err } else { glog.V(4).Infof("Factory %q was unable to handle container %q", factory, name) } } return nil, false, fmt.Errorf("no known factory can handle creation of container") } // Clear the known factories. func ClearContainerHandlerFactories() { factoriesLock.Lock() defer factoriesLock.Unlock() factories = map[watcher.ContainerWatchSource][]ContainerHandlerFactory{} } func DebugInfo() map[string][]string { factoriesLock.RLock() defer factoriesLock.RUnlock() // Get debug information for all factories. out := make(map[string][]string) for _, factoriesSlice := range factories { for _, factory := range factoriesSlice { for k, v := range factory.DebugInfo() { out[k] = v } } } return out } cadvisor-0.25.0/container/factory_test.go000066400000000000000000000120001306035727200204250ustar00rootroot00000000000000// 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_test import ( "testing" "github.com/google/cadvisor/container" containertest "github.com/google/cadvisor/container/testing" "github.com/google/cadvisor/manager/watcher" "github.com/stretchr/testify/mock" ) type mockContainerHandlerFactory struct { mock.Mock Name string CanHandleValue bool CanAcceptValue bool } func (self *mockContainerHandlerFactory) String() string { return self.Name } func (self *mockContainerHandlerFactory) DebugInfo() map[string][]string { return map[string][]string{} } func (self *mockContainerHandlerFactory) CanHandleAndAccept(name string) (bool, bool, error) { return self.CanHandleValue, self.CanAcceptValue, nil } func (self *mockContainerHandlerFactory) NewContainerHandler(name string, isHostNamespace bool) (container.ContainerHandler, error) { args := self.Called(name) return args.Get(0).(container.ContainerHandler), args.Error(1) } const testContainerName = "/test" var mockFactory containertest.FactoryForMockContainerHandler func TestNewContainerHandler_FirstMatches(t *testing.T) { container.ClearContainerHandlerFactories() // Register one allways yes factory. allwaysYes := &mockContainerHandlerFactory{ Name: "yes", CanHandleValue: true, CanAcceptValue: true, } container.RegisterContainerHandlerFactory(allwaysYes, []watcher.ContainerWatchSource{watcher.Raw}) // The yes factory should be asked to create the ContainerHandler. mockContainer, err := mockFactory.NewContainerHandler(testContainerName, true) if err != nil { t.Error(err) } allwaysYes.On("NewContainerHandler", testContainerName).Return(mockContainer, nil) cont, _, err := container.NewContainerHandler(testContainerName, watcher.Raw, true) if err != nil { t.Error(err) } if cont == nil { t.Error("Expected container to not be nil") } } func TestNewContainerHandler_SecondMatches(t *testing.T) { container.ClearContainerHandlerFactories() // Register one allways no and one always yes factory. allwaysNo := &mockContainerHandlerFactory{ Name: "no", CanHandleValue: false, CanAcceptValue: true, } container.RegisterContainerHandlerFactory(allwaysNo, []watcher.ContainerWatchSource{watcher.Raw}) allwaysYes := &mockContainerHandlerFactory{ Name: "yes", CanHandleValue: true, CanAcceptValue: true, } container.RegisterContainerHandlerFactory(allwaysYes, []watcher.ContainerWatchSource{watcher.Raw}) // The yes factory should be asked to create the ContainerHandler. mockContainer, err := mockFactory.NewContainerHandler(testContainerName, true) if err != nil { t.Error(err) } allwaysYes.On("NewContainerHandler", testContainerName).Return(mockContainer, nil) cont, _, err := container.NewContainerHandler(testContainerName, watcher.Raw, true) if err != nil { t.Error(err) } if cont == nil { t.Error("Expected container to not be nil") } } func TestNewContainerHandler_NoneMatch(t *testing.T) { container.ClearContainerHandlerFactories() // Register two allways no factories. allwaysNo1 := &mockContainerHandlerFactory{ Name: "no", CanHandleValue: false, CanAcceptValue: true, } container.RegisterContainerHandlerFactory(allwaysNo1, []watcher.ContainerWatchSource{watcher.Raw}) allwaysNo2 := &mockContainerHandlerFactory{ Name: "no", CanHandleValue: false, CanAcceptValue: true, } container.RegisterContainerHandlerFactory(allwaysNo2, []watcher.ContainerWatchSource{watcher.Raw}) _, _, err := container.NewContainerHandler(testContainerName, watcher.Raw, true) if err == nil { t.Error("Expected NewContainerHandler to fail") } } func TestNewContainerHandler_Accept(t *testing.T) { container.ClearContainerHandlerFactories() // Register handler that can handle the container, but can't accept it. cannotHandle := &mockContainerHandlerFactory{ Name: "no", CanHandleValue: false, CanAcceptValue: true, } container.RegisterContainerHandlerFactory(cannotHandle, []watcher.ContainerWatchSource{watcher.Raw}) cannotAccept := &mockContainerHandlerFactory{ Name: "no", CanHandleValue: true, CanAcceptValue: false, } container.RegisterContainerHandlerFactory(cannotAccept, []watcher.ContainerWatchSource{watcher.Raw}) _, accept, err := container.NewContainerHandler(testContainerName, watcher.Raw, true) if err != nil { t.Error("Expected NewContainerHandler to succeed") } if accept == true { t.Error("Expected NewContainerHandler to ignore the container.") } } cadvisor-0.25.0/container/libcontainer/000077500000000000000000000000001306035727200200505ustar00rootroot00000000000000cadvisor-0.25.0/container/libcontainer/helpers.go000066400000000000000000000277511306035727200220550ustar00rootroot00000000000000// 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 libcontainer import ( "bufio" "fmt" "io/ioutil" "os" "path" "strconv" "strings" "time" "github.com/google/cadvisor/container" info "github.com/google/cadvisor/info/v1" "github.com/golang/glog" "github.com/opencontainers/runc/libcontainer" "github.com/opencontainers/runc/libcontainer/cgroups" ) type CgroupSubsystems struct { // Cgroup subsystem mounts. // e.g.: "/sys/fs/cgroup/cpu" -> ["cpu", "cpuacct"] Mounts []cgroups.Mount // Cgroup subsystem to their mount location. // e.g.: "cpu" -> "/sys/fs/cgroup/cpu" MountPoints map[string]string } // Get information about the cgroup subsystems. func GetCgroupSubsystems() (CgroupSubsystems, error) { // Get all cgroup mounts. allCgroups, err := cgroups.GetCgroupMounts(true) if err != nil { return CgroupSubsystems{}, err } if len(allCgroups) == 0 { return CgroupSubsystems{}, fmt.Errorf("failed to find cgroup mounts") } // Trim the mounts to only the subsystems we care about. supportedCgroups := make([]cgroups.Mount, 0, len(allCgroups)) mountPoints := make(map[string]string, len(allCgroups)) for _, mount := range allCgroups { for _, subsystem := range mount.Subsystems { if _, ok := supportedSubsystems[subsystem]; ok { supportedCgroups = append(supportedCgroups, mount) mountPoints[subsystem] = mount.Mountpoint } } } return CgroupSubsystems{ Mounts: supportedCgroups, MountPoints: mountPoints, }, nil } // Cgroup subsystems we support listing (should be the minimal set we need stats from). var supportedSubsystems map[string]struct{} = map[string]struct{}{ "cpu": {}, "cpuacct": {}, "memory": {}, "cpuset": {}, "blkio": {}, } // Get cgroup and networking stats of the specified container func GetStats(cgroupManager cgroups.Manager, rootFs string, pid int, ignoreMetrics container.MetricSet) (*info.ContainerStats, error) { cgroupStats, err := cgroupManager.GetStats() if err != nil { return nil, err } libcontainerStats := &libcontainer.Stats{ CgroupStats: cgroupStats, } stats := newContainerStats(libcontainerStats) // If we know the pid then get network stats from /proc//net/dev if pid == 0 { return stats, nil } if !ignoreMetrics.Has(container.NetworkUsageMetrics) { netStats, err := networkStatsFromProc(rootFs, pid) if err != nil { glog.V(2).Infof("Unable to get network stats from pid %d: %v", pid, err) } else { stats.Network.Interfaces = append(stats.Network.Interfaces, netStats...) } } if !ignoreMetrics.Has(container.NetworkTcpUsageMetrics) { t, err := tcpStatsFromProc(rootFs, pid, "net/tcp") if err != nil { glog.V(2).Infof("Unable to get tcp stats from pid %d: %v", pid, err) } else { stats.Network.Tcp = t } t6, err := tcpStatsFromProc(rootFs, pid, "net/tcp6") if err != nil { glog.V(2).Infof("Unable to get tcp6 stats from pid %d: %v", pid, err) } else { stats.Network.Tcp6 = t6 } } // For backwards compatibility. if len(stats.Network.Interfaces) > 0 { stats.Network.InterfaceStats = stats.Network.Interfaces[0] } return stats, nil } func networkStatsFromProc(rootFs string, pid int) ([]info.InterfaceStats, error) { netStatsFile := path.Join(rootFs, "proc", strconv.Itoa(pid), "/net/dev") ifaceStats, err := scanInterfaceStats(netStatsFile) if err != nil { return []info.InterfaceStats{}, fmt.Errorf("couldn't read network stats: %v", err) } return ifaceStats, nil } var ( ignoredDevicePrefixes = []string{"lo", "veth", "docker"} ) func isIgnoredDevice(ifName string) bool { for _, prefix := range ignoredDevicePrefixes { if strings.HasPrefix(strings.ToLower(ifName), prefix) { return true } } return false } func scanInterfaceStats(netStatsFile string) ([]info.InterfaceStats, error) { file, err := os.Open(netStatsFile) if err != nil { return nil, fmt.Errorf("failure opening %s: %v", netStatsFile, err) } defer file.Close() scanner := bufio.NewScanner(file) // Discard header lines for i := 0; i < 2; i++ { if b := scanner.Scan(); !b { return nil, scanner.Err() } } stats := []info.InterfaceStats{} for scanner.Scan() { line := scanner.Text() line = strings.Replace(line, ":", "", -1) fields := strings.Fields(line) // If the format of the line is invalid then don't trust any of the stats // in this file. if len(fields) != 17 { return nil, fmt.Errorf("invalid interface stats line: %v", line) } devName := fields[0] if isIgnoredDevice(devName) { continue } i := info.InterfaceStats{ Name: devName, } statFields := append(fields[1:5], fields[9:13]...) statPointers := []*uint64{ &i.RxBytes, &i.RxPackets, &i.RxErrors, &i.RxDropped, &i.TxBytes, &i.TxPackets, &i.TxErrors, &i.TxDropped, } err := setInterfaceStatValues(statFields, statPointers) if err != nil { return nil, fmt.Errorf("cannot parse interface stats (%v): %v", err, line) } stats = append(stats, i) } return stats, nil } func setInterfaceStatValues(fields []string, pointers []*uint64) error { for i, v := range fields { val, err := strconv.ParseUint(v, 10, 64) if err != nil { return err } *pointers[i] = val } return nil } func tcpStatsFromProc(rootFs string, pid int, file string) (info.TcpStat, error) { tcpStatsFile := path.Join(rootFs, "proc", strconv.Itoa(pid), file) tcpStats, err := scanTcpStats(tcpStatsFile) if err != nil { return tcpStats, fmt.Errorf("couldn't read tcp stats: %v", err) } return tcpStats, nil } func scanTcpStats(tcpStatsFile string) (info.TcpStat, error) { var stats info.TcpStat data, err := ioutil.ReadFile(tcpStatsFile) if err != nil { return stats, fmt.Errorf("failure opening %s: %v", tcpStatsFile, err) } tcpStateMap := map[string]uint64{ "01": 0, //ESTABLISHED "02": 0, //SYN_SENT "03": 0, //SYN_RECV "04": 0, //FIN_WAIT1 "05": 0, //FIN_WAIT2 "06": 0, //TIME_WAIT "07": 0, //CLOSE "08": 0, //CLOSE_WAIT "09": 0, //LAST_ACK "0A": 0, //LISTEN "0B": 0, //CLOSING } reader := strings.NewReader(string(data)) scanner := bufio.NewScanner(reader) scanner.Split(bufio.ScanLines) // Discard header line if b := scanner.Scan(); !b { return stats, scanner.Err() } for scanner.Scan() { line := scanner.Text() state := strings.Fields(line) // TCP state is the 4th field. // Format: sl local_address rem_address st tx_queue rx_queue tr tm->when retrnsmt uid timeout inode tcpState := state[3] _, ok := tcpStateMap[tcpState] if !ok { return stats, fmt.Errorf("invalid TCP stats line: %v", line) } tcpStateMap[tcpState]++ } stats = info.TcpStat{ Established: tcpStateMap["01"], SynSent: tcpStateMap["02"], SynRecv: tcpStateMap["03"], FinWait1: tcpStateMap["04"], FinWait2: tcpStateMap["05"], TimeWait: tcpStateMap["06"], Close: tcpStateMap["07"], CloseWait: tcpStateMap["08"], LastAck: tcpStateMap["09"], Listen: tcpStateMap["0A"], Closing: tcpStateMap["0B"], } return stats, nil } func GetProcesses(cgroupManager cgroups.Manager) ([]int, error) { pids, err := cgroupManager.GetPids() if err != nil { return nil, err } return pids, nil } func DiskStatsCopy0(major, minor uint64) *info.PerDiskStats { disk := info.PerDiskStats{ Major: major, Minor: minor, } disk.Stats = make(map[string]uint64) return &disk } type DiskKey struct { Major uint64 Minor uint64 } func DiskStatsCopy1(disk_stat map[DiskKey]*info.PerDiskStats) []info.PerDiskStats { i := 0 stat := make([]info.PerDiskStats, len(disk_stat)) for _, disk := range disk_stat { stat[i] = *disk i++ } return stat } func DiskStatsCopy(blkio_stats []cgroups.BlkioStatEntry) (stat []info.PerDiskStats) { if len(blkio_stats) == 0 { return } disk_stat := make(map[DiskKey]*info.PerDiskStats) for i := range blkio_stats { major := blkio_stats[i].Major minor := blkio_stats[i].Minor disk_key := DiskKey{ Major: major, Minor: minor, } diskp, ok := disk_stat[disk_key] if !ok { diskp = DiskStatsCopy0(major, minor) disk_stat[disk_key] = diskp } op := blkio_stats[i].Op if op == "" { op = "Count" } diskp.Stats[op] = blkio_stats[i].Value } return DiskStatsCopy1(disk_stat) } // Convert libcontainer stats to info.ContainerStats. func setCpuStats(s *cgroups.Stats, ret *info.ContainerStats) { 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.Cpu.CFS.Periods = s.CpuStats.ThrottlingData.Periods ret.Cpu.CFS.ThrottledPeriods = s.CpuStats.ThrottlingData.ThrottledPeriods ret.Cpu.CFS.ThrottledTime = s.CpuStats.ThrottlingData.ThrottledTime } func setDiskIoStats(s *cgroups.Stats, ret *info.ContainerStats) { ret.DiskIo.IoServiceBytes = DiskStatsCopy(s.BlkioStats.IoServiceBytesRecursive) ret.DiskIo.IoServiced = DiskStatsCopy(s.BlkioStats.IoServicedRecursive) ret.DiskIo.IoQueued = DiskStatsCopy(s.BlkioStats.IoQueuedRecursive) ret.DiskIo.Sectors = DiskStatsCopy(s.BlkioStats.SectorsRecursive) ret.DiskIo.IoServiceTime = DiskStatsCopy(s.BlkioStats.IoServiceTimeRecursive) ret.DiskIo.IoWaitTime = DiskStatsCopy(s.BlkioStats.IoWaitTimeRecursive) ret.DiskIo.IoMerged = DiskStatsCopy(s.BlkioStats.IoMergedRecursive) ret.DiskIo.IoTime = DiskStatsCopy(s.BlkioStats.IoTimeRecursive) } func setMemoryStats(s *cgroups.Stats, ret *info.ContainerStats) { ret.Memory.Usage = s.MemoryStats.Usage.Usage ret.Memory.Failcnt = s.MemoryStats.Usage.Failcnt ret.Memory.Cache = s.MemoryStats.Stats["cache"] ret.Memory.RSS = s.MemoryStats.Stats["rss"] ret.Memory.Swap = s.MemoryStats.Stats["swap"] 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 } workingSet := ret.Memory.Usage if v, ok := s.MemoryStats.Stats["total_inactive_file"]; ok { if workingSet < v { workingSet = 0 } else { workingSet -= v } } ret.Memory.WorkingSet = workingSet } func setNetworkStats(libcontainerStats *libcontainer.Stats, ret *info.ContainerStats) { ret.Network.Interfaces = make([]info.InterfaceStats, len(libcontainerStats.Interfaces)) for i := range libcontainerStats.Interfaces { ret.Network.Interfaces[i] = info.InterfaceStats{ Name: libcontainerStats.Interfaces[i].Name, RxBytes: libcontainerStats.Interfaces[i].RxBytes, RxPackets: libcontainerStats.Interfaces[i].RxPackets, RxErrors: libcontainerStats.Interfaces[i].RxErrors, RxDropped: libcontainerStats.Interfaces[i].RxDropped, TxBytes: libcontainerStats.Interfaces[i].TxBytes, TxPackets: libcontainerStats.Interfaces[i].TxPackets, TxErrors: libcontainerStats.Interfaces[i].TxErrors, TxDropped: libcontainerStats.Interfaces[i].TxDropped, } } // Add to base struct for backwards compatibility. if len(ret.Network.Interfaces) > 0 { ret.Network.InterfaceStats = ret.Network.Interfaces[0] } } func newContainerStats(libcontainerStats *libcontainer.Stats) *info.ContainerStats { ret := &info.ContainerStats{ Timestamp: time.Now(), } if s := libcontainerStats.CgroupStats; s != nil { setCpuStats(s, ret) setDiskIoStats(s, ret) setMemoryStats(s, ret) } if len(libcontainerStats.Interfaces) > 0 { setNetworkStats(libcontainerStats, ret) } return ret } cadvisor-0.25.0/container/libcontainer/helpers_test.go000066400000000000000000000026451306035727200231070ustar00rootroot00000000000000// 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 libcontainer import ( "testing" info "github.com/google/cadvisor/info/v1" ) func TestScanInterfaceStats(t *testing.T) { stats, err := scanInterfaceStats("testdata/procnetdev") if err != nil { t.Error(err) } var netdevstats = []info.InterfaceStats{ { Name: "wlp4s0", RxBytes: 1, RxPackets: 2, RxErrors: 3, RxDropped: 4, TxBytes: 9, TxPackets: 10, TxErrors: 11, TxDropped: 12, }, { Name: "em1", RxBytes: 315849, RxPackets: 1172, RxErrors: 0, RxDropped: 0, TxBytes: 315850, TxPackets: 1173, TxErrors: 0, TxDropped: 0, }, } if len(stats) != len(netdevstats) { t.Errorf("Expected 2 net stats, got %d", len(stats)) } for i, v := range netdevstats { if v != stats[i] { t.Errorf("Expected %#v, got %#v", v, stats[i]) } } } cadvisor-0.25.0/container/libcontainer/testdata/000077500000000000000000000000001306035727200216615ustar00rootroot00000000000000cadvisor-0.25.0/container/libcontainer/testdata/docker-v1.8.3/000077500000000000000000000000001306035727200237635ustar00rootroot00000000000000cadvisor-0.25.0/container/libcontainer/testdata/docker-v1.8.3/execdriver/000077500000000000000000000000001306035727200261235ustar00rootroot00000000000000cadvisor-0.25.0/container/libcontainer/testdata/docker-v1.8.3/execdriver/native/000077500000000000000000000000001306035727200274115ustar00rootroot00000000000000cadvisor-0.25.0/container/libcontainer/testdata/docker-v1.8.3/execdriver/native/1/000077500000000000000000000000001306035727200275515ustar00rootroot00000000000000cadvisor-0.25.0/container/libcontainer/testdata/docker-v1.8.3/execdriver/native/1/state.json000066400000000000000000000136121306035727200315670ustar00rootroot00000000000000{"id":"1","init_process_pid":66241,"init_process_start":"4507843","cgroup_paths":{"blkio":"/sys/fs/cgroup/blkio/docker/1","cpu":"/sys/fs/cgroup/cpu/docker/1","cpuacct":"/sys/fs/cgroup/cpuacct/docker/1","cpuset":"/sys/fs/cgroup/cpuset/docker/1","devices":"/sys/fs/cgroup/devices/docker/1","freezer":"/sys/fs/cgroup/freezer/docker/1","hugetlb":"/sys/fs/cgroup/hugetlb/docker/1","memory":"/sys/fs/cgroup/memory/docker/1","net_cls":"/sys/fs/cgroup/net_cls/docker/1","net_prio":"/sys/fs/cgroup/net_prio/docker/1","perf_event":"/sys/fs/cgroup/perf_event/docker/1"},"namespace_paths":{"NEWIPC":"/proc/66241/ns/ipc","NEWNET":"/var/run/docker/netns/e05ddb1777f3","NEWNS":"/proc/66241/ns/mnt","NEWPID":"/proc/66241/ns/pid","NEWUSER":"/proc/66241/ns/user","NEWUTS":"/proc/66241/ns/uts"},"config":{"no_pivot_root":false,"parent_death_signal":0,"pivot_dir":"","rootfs":"/var/lib/docker/devicemapper/mnt/1/rootfs","readonlyfs":false,"privatefs":true,"mounts":[{"source":"proc","destination":"/proc","device":"proc","flags":14,"data":"","relabel":"","premount_cmds":null,"postmount_cmds":null},{"source":"tmpfs","destination":"/dev","device":"tmpfs","flags":16777218,"data":"mode=755","relabel":"","premount_cmds":null,"postmount_cmds":null},{"source":"devpts","destination":"/dev/pts","device":"devpts","flags":10,"data":"newinstance,ptmxmode=0666,mode=0620,gid=5","relabel":"","premount_cmds":null,"postmount_cmds":null},{"source":"shm","destination":"/dev/shm","device":"tmpfs","flags":14,"data":"mode=1777,size=65536k","relabel":"","premount_cmds":null,"postmount_cmds":null},{"source":"mqueue","destination":"/dev/mqueue","device":"mqueue","flags":14,"data":"","relabel":"","premount_cmds":null,"postmount_cmds":null},{"source":"sysfs","destination":"/sys","device":"sysfs","flags":15,"data":"","relabel":"","premount_cmds":null,"postmount_cmds":null},{"source":"cgroup","destination":"/sys/fs/cgroup","device":"cgroup","flags":15,"data":"","relabel":"","premount_cmds":null,"postmount_cmds":null},{"source":"/var/lib/docker/containers/1/resolv.conf","destination":"/etc/resolv.conf","device":"bind","flags":20480,"data":"","relabel":"","premount_cmds":null,"postmount_cmds":null},{"source":"/var/lib/docker/containers/1/hostname","destination":"/etc/hostname","device":"bind","flags":20480,"data":"","relabel":"","premount_cmds":null,"postmount_cmds":null},{"source":"/var/lib/docker/containers/1/hosts","destination":"/etc/hosts","device":"bind","flags":20480,"data":"","relabel":"","premount_cmds":null,"postmount_cmds":null}],"devices":[{"type":99,"path":"/dev/fuse","major":10,"minor":229,"permissions":"rwm","file_mode":0,"uid":0,"gid":0},{"type":99,"path":"/dev/null","major":1,"minor":3,"permissions":"rwm","file_mode":438,"uid":0,"gid":0},{"type":99,"path":"/dev/zero","major":1,"minor":5,"permissions":"rwm","file_mode":438,"uid":0,"gid":0},{"type":99,"path":"/dev/full","major":1,"minor":7,"permissions":"rwm","file_mode":438,"uid":0,"gid":0},{"type":99,"path":"/dev/tty","major":5,"minor":0,"permissions":"rwm","file_mode":438,"uid":0,"gid":0},{"type":99,"path":"/dev/urandom","major":1,"minor":9,"permissions":"rwm","file_mode":438,"uid":0,"gid":0},{"type":99,"path":"/dev/random","major":1,"minor":8,"permissions":"rwm","file_mode":438,"uid":0,"gid":0}],"mount_label":"","hostname":"1","namespaces":[{"type":"NEWNS","path":""},{"type":"NEWUTS","path":""},{"type":"NEWIPC","path":""},{"type":"NEWPID","path":""},{"type":"NEWNET","path":"/var/run/docker/netns/e05ddb1777f3"}],"capabilities":["CHOWN","DAC_OVERRIDE","FSETID","FOWNER","MKNOD","NET_RAW","SETGID","SETUID","SETFCAP","SETPCAP","NET_BIND_SERVICE","SYS_CHROOT","KILL","AUDIT_WRITE"],"networks":null,"routes":null,"cgroups":{"name":"1","parent":"docker","allow_all_devices":false,"allowed_devices":[{"type":99,"path":"","major":-1,"minor":-1,"permissions":"m","file_mode":0,"uid":0,"gid":0},{"type":98,"path":"","major":-1,"minor":-1,"permissions":"m","file_mode":0,"uid":0,"gid":0},{"type":99,"path":"/dev/console","major":5,"minor":1,"permissions":"rwm","file_mode":0,"uid":0,"gid":0},{"type":99,"path":"/dev/tty0","major":4,"minor":0,"permissions":"rwm","file_mode":0,"uid":0,"gid":0},{"type":99,"path":"/dev/tty1","major":4,"minor":1,"permissions":"rwm","file_mode":0,"uid":0,"gid":0},{"type":99,"path":"","major":136,"minor":-1,"permissions":"rwm","file_mode":0,"uid":0,"gid":0},{"type":99,"path":"","major":5,"minor":2,"permissions":"rwm","file_mode":0,"uid":0,"gid":0},{"type":99,"path":"","major":10,"minor":200,"permissions":"rwm","file_mode":0,"uid":0,"gid":0},{"type":99,"path":"/dev/null","major":1,"minor":3,"permissions":"rwm","file_mode":438,"uid":0,"gid":0},{"type":99,"path":"/dev/zero","major":1,"minor":5,"permissions":"rwm","file_mode":438,"uid":0,"gid":0},{"type":99,"path":"/dev/full","major":1,"minor":7,"permissions":"rwm","file_mode":438,"uid":0,"gid":0},{"type":99,"path":"/dev/tty","major":5,"minor":0,"permissions":"rwm","file_mode":438,"uid":0,"gid":0},{"type":99,"path":"/dev/urandom","major":1,"minor":9,"permissions":"rwm","file_mode":438,"uid":0,"gid":0},{"type":99,"path":"/dev/random","major":1,"minor":8,"permissions":"rwm","file_mode":438,"uid":0,"gid":0}],"denied_devices":null,"memory":0,"memory_reservation":0,"memory_swap":0,"kernel_memory":0,"cpu_shares":0,"cpuset_cpus":"","cpuset_mems":"","blkio_throttle_read_bps_device":"","blkio_throttle_write_bps_device":"","blkio_throttle_read_iops_device":"","blkio_throttle_write_iops_device":"","blkio_weight":0,"blkio_weight_device":"","freezer":"","hugetlb_limit":null,"slice":"","oom_kill_disable":false,"memory_swappiness":-1,"net_prio_ifpriomap":null,"net_cls_classid":""},"apparmor_profile":"docker-default","process_label":"","rlimits":null,"additional_groups":null,"uid_mappings":null,"gid_mappings":null,"mask_paths":["/proc/kcore","/proc/latency_stats","/proc/timer_stats"],"readonly_paths":["/proc/asound","/proc/bus","/proc/fs","/proc/irq","/proc/sys","/proc/sysrq-trigger"],"sysctl":null,"seccomp":null},"external_descriptors":["/dev/null","/dev/null","/dev/null"]} cadvisor-0.25.0/container/libcontainer/testdata/docker-v1.9.1/000077500000000000000000000000001306035727200237625ustar00rootroot00000000000000cadvisor-0.25.0/container/libcontainer/testdata/docker-v1.9.1/execdriver/000077500000000000000000000000001306035727200261225ustar00rootroot00000000000000cadvisor-0.25.0/container/libcontainer/testdata/docker-v1.9.1/execdriver/native/000077500000000000000000000000001306035727200274105ustar00rootroot00000000000000cadvisor-0.25.0/container/libcontainer/testdata/docker-v1.9.1/execdriver/native/1/000077500000000000000000000000001306035727200275505ustar00rootroot00000000000000cadvisor-0.25.0/container/libcontainer/testdata/docker-v1.9.1/execdriver/native/1/state.json000066400000000000000000000143711306035727200315710ustar00rootroot00000000000000{"id":"1","init_process_pid":64076,"init_process_start":"3211353","cgroup_paths":{"blkio":"/sys/fs/cgroup/blkio/docker/1","cpu":"/sys/fs/cgroup/cpu/docker/1","cpuacct":"/sys/fs/cgroup/cpuacct/docker/1","cpuset":"/sys/fs/cgroup/cpuset/docker/1","devices":"/sys/fs/cgroup/devices/docker/1","freezer":"/sys/fs/cgroup/freezer/docker/1","hugetlb":"/sys/fs/cgroup/hugetlb/docker/1","memory":"/sys/fs/cgroup/memory/docker/1","net_cls":"/sys/fs/cgroup/net_cls/docker/1","net_prio":"/sys/fs/cgroup/net_prio/docker/1","perf_event":"/sys/fs/cgroup/perf_event/docker/1"},"namespace_paths":{"NEWIPC":"/proc/64076/ns/ipc","NEWNET":"/proc/64076/ns/net","NEWNS":"/proc/64076/ns/mnt","NEWPID":"/proc/64076/ns/pid","NEWUSER":"/proc/64076/ns/user","NEWUTS":"/proc/64076/ns/uts"},"config":{"no_pivot_root":false,"parent_death_signal":0,"pivot_dir":"","rootfs":"/var/lib/docker/devicemapper/mnt/1/rootfs","readonlyfs":false,"rootPropagation":278528,"mounts":[{"source":"proc","destination":"/proc","device":"proc","flags":14,"propagation_flags":null,"data":"","relabel":"","premount_cmds":null,"postmount_cmds":null},{"source":"tmpfs","destination":"/dev","device":"tmpfs","flags":16777218,"propagation_flags":null,"data":"mode=755","relabel":"","premount_cmds":null,"postmount_cmds":null},{"source":"devpts","destination":"/dev/pts","device":"devpts","flags":10,"propagation_flags":null,"data":"newinstance,ptmxmode=0666,mode=0620,gid=5","relabel":"","premount_cmds":null,"postmount_cmds":null},{"source":"sysfs","destination":"/sys","device":"sysfs","flags":15,"propagation_flags":null,"data":"","relabel":"","premount_cmds":null,"postmount_cmds":null},{"source":"cgroup","destination":"/sys/fs/cgroup","device":"cgroup","flags":15,"propagation_flags":null,"data":"","relabel":"","premount_cmds":null,"postmount_cmds":null},{"source":"/var/lib/docker/containers/1/resolv.conf","destination":"/etc/resolv.conf","device":"bind","flags":20480,"propagation_flags":null,"data":"","relabel":"","premount_cmds":null,"postmount_cmds":null},{"source":"/var/lib/docker/containers/1/hostname","destination":"/etc/hostname","device":"bind","flags":20480,"propagation_flags":null,"data":"","relabel":"","premount_cmds":null,"postmount_cmds":null},{"source":"/var/lib/docker/containers/1/hosts","destination":"/etc/hosts","device":"bind","flags":20480,"propagation_flags":null,"data":"","relabel":"","premount_cmds":null,"postmount_cmds":null},{"source":"/var/lib/docker/containers/1/shm","destination":"/dev/shm","device":"bind","flags":20480,"propagation_flags":null,"data":"","relabel":"","premount_cmds":null,"postmount_cmds":null},{"source":"/var/lib/docker/containers/1/mqueue","destination":"/dev/mqueue","device":"bind","flags":20480,"propagation_flags":null,"data":"","relabel":"","premount_cmds":null,"postmount_cmds":null}],"devices":[{"type":99,"path":"/dev/fuse","major":10,"minor":229,"permissions":"rwm","file_mode":0,"uid":0,"gid":0},{"type":99,"path":"/dev/null","major":1,"minor":3,"permissions":"rwm","file_mode":438,"uid":0,"gid":0},{"type":99,"path":"/dev/zero","major":1,"minor":5,"permissions":"rwm","file_mode":438,"uid":0,"gid":0},{"type":99,"path":"/dev/full","major":1,"minor":7,"permissions":"rwm","file_mode":438,"uid":0,"gid":0},{"type":99,"path":"/dev/tty","major":5,"minor":0,"permissions":"rwm","file_mode":438,"uid":0,"gid":0},{"type":99,"path":"/dev/urandom","major":1,"minor":9,"permissions":"rwm","file_mode":438,"uid":0,"gid":0},{"type":99,"path":"/dev/random","major":1,"minor":8,"permissions":"rwm","file_mode":438,"uid":0,"gid":0}],"mount_label":"","hostname":"1","namespaces":[{"type":"NEWNS","path":""},{"type":"NEWUTS","path":""},{"type":"NEWIPC","path":""},{"type":"NEWPID","path":""},{"type":"NEWNET","path":""}],"capabilities":["CAP_CHOWN","CAP_DAC_OVERRIDE","CAP_FSETID","CAP_FOWNER","CAP_MKNOD","CAP_NET_RAW","CAP_SETGID","CAP_SETUID","CAP_SETFCAP","CAP_SETPCAP","CAP_NET_BIND_SERVICE","CAP_SYS_CHROOT","CAP_KILL","CAP_AUDIT_WRITE"],"networks":null,"routes":null,"cgroups":{"name":"1","parent":"docker","allow_all_devices":false,"allowed_devices":[{"type":99,"path":"","major":-1,"minor":-1,"permissions":"m","file_mode":0,"uid":0,"gid":0},{"type":98,"path":"","major":-1,"minor":-1,"permissions":"m","file_mode":0,"uid":0,"gid":0},{"type":99,"path":"/dev/console","major":5,"minor":1,"permissions":"rwm","file_mode":0,"uid":0,"gid":0},{"type":99,"path":"/dev/tty0","major":4,"minor":0,"permissions":"rwm","file_mode":0,"uid":0,"gid":0},{"type":99,"path":"/dev/tty1","major":4,"minor":1,"permissions":"rwm","file_mode":0,"uid":0,"gid":0},{"type":99,"path":"","major":136,"minor":-1,"permissions":"rwm","file_mode":0,"uid":0,"gid":0},{"type":99,"path":"","major":5,"minor":2,"permissions":"rwm","file_mode":0,"uid":0,"gid":0},{"type":99,"path":"","major":10,"minor":200,"permissions":"rwm","file_mode":0,"uid":0,"gid":0},{"type":99,"path":"/dev/null","major":1,"minor":3,"permissions":"rwm","file_mode":438,"uid":0,"gid":0},{"type":99,"path":"/dev/zero","major":1,"minor":5,"permissions":"rwm","file_mode":438,"uid":0,"gid":0},{"type":99,"path":"/dev/full","major":1,"minor":7,"permissions":"rwm","file_mode":438,"uid":0,"gid":0},{"type":99,"path":"/dev/tty","major":5,"minor":0,"permissions":"rwm","file_mode":438,"uid":0,"gid":0},{"type":99,"path":"/dev/urandom","major":1,"minor":9,"permissions":"rwm","file_mode":438,"uid":0,"gid":0},{"type":99,"path":"/dev/random","major":1,"minor":8,"permissions":"rwm","file_mode":438,"uid":0,"gid":0}],"denied_devices":null,"memory":0,"memory_reservation":0,"memory_swap":0,"kernel_memory":0,"cpu_shares":0,"cpuset_cpus":"","cpuset_mems":"","blkio_weight":0,"blkio_leaf_weight":0,"blkio_weight_device":null,"blkio_throttle_read_bps_device":null,"blkio_throttle_write_bps_device":null,"blkio_throttle_read_iops_device":null,"blkio_throttle_write_iops_device":null,"freezer":"","hugetlb_limit":null,"slice":"","oom_kill_disable":false,"memory_swappiness":-1,"net_prio_ifpriomap":null,"net_cls_classid":""},"apparmor_profile":"docker-default","process_label":"","rlimits":null,"oom_score_adj":0,"additional_groups":null,"uid_mappings":null,"gid_mappings":null,"mask_paths":["/proc/kcore","/proc/latency_stats","/proc/timer_stats"],"readonly_paths":["/proc/asound","/proc/bus","/proc/fs","/proc/irq","/proc/sys","/proc/sysrq-trigger"],"sysctl":null,"seccomp":null,"version":""},"external_descriptors":["/dev/null","/dev/null","/dev/null"]} cadvisor-0.25.0/container/libcontainer/testdata/procnetdev000066400000000000000000000012521306035727200237550ustar00rootroot00000000000000Inter-| Receive | Transmit face |bytes packets errs drop fifo frame compressed multicast|bytes packets errs drop fifo colls carrier compressed wlp4s0: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0 docker0: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 lo: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 em1: 315849 1172 0 0 0 0 0 0 315850 1173 0 0 0 0 0 0cadvisor-0.25.0/container/raw/000077500000000000000000000000001306035727200161705ustar00rootroot00000000000000cadvisor-0.25.0/container/raw/factory.go000066400000000000000000000057661306035727200202040ustar00rootroot00000000000000// 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 raw import ( "flag" "fmt" "github.com/google/cadvisor/container" "github.com/google/cadvisor/container/common" "github.com/google/cadvisor/container/libcontainer" "github.com/google/cadvisor/fs" info "github.com/google/cadvisor/info/v1" watch "github.com/google/cadvisor/manager/watcher" "github.com/golang/glog" ) var dockerOnly = flag.Bool("docker_only", false, "Only report docker containers in addition to root stats") type rawFactory struct { // Factory for machine information. machineInfoFactory info.MachineInfoFactory // Information about the cgroup subsystems. cgroupSubsystems *libcontainer.CgroupSubsystems // Information about mounted filesystems. fsInfo fs.FsInfo // Watcher for inotify events. watcher *common.InotifyWatcher // List of metrics to be ignored. ignoreMetrics map[container.MetricKind]struct{} } func (self *rawFactory) String() string { return "raw" } func (self *rawFactory) NewContainerHandler(name string, inHostNamespace bool) (container.ContainerHandler, error) { rootFs := "/" if !inHostNamespace { rootFs = "/rootfs" } return newRawContainerHandler(name, self.cgroupSubsystems, self.machineInfoFactory, self.fsInfo, self.watcher, rootFs, self.ignoreMetrics) } // The raw factory can handle any container. If --docker_only is set to false, non-docker containers are ignored. func (self *rawFactory) CanHandleAndAccept(name string) (bool, bool, error) { accept := name == "/" || !*dockerOnly return true, accept, nil } func (self *rawFactory) DebugInfo() map[string][]string { return common.DebugInfo(self.watcher.GetWatches()) } func Register(machineInfoFactory info.MachineInfoFactory, fsInfo fs.FsInfo, ignoreMetrics map[container.MetricKind]struct{}) error { cgroupSubsystems, err := libcontainer.GetCgroupSubsystems() if err != nil { return fmt.Errorf("failed to get cgroup subsystems: %v", err) } if len(cgroupSubsystems.Mounts) == 0 { return fmt.Errorf("failed to find supported cgroup mounts for the raw factory") } watcher, err := common.NewInotifyWatcher() if err != nil { return err } glog.Infof("Registering Raw factory") factory := &rawFactory{ machineInfoFactory: machineInfoFactory, fsInfo: fsInfo, cgroupSubsystems: &cgroupSubsystems, watcher: watcher, ignoreMetrics: ignoreMetrics, } container.RegisterContainerHandlerFactory(factory, []watch.ContainerWatchSource{watch.Raw}) return nil } cadvisor-0.25.0/container/raw/handler.go000066400000000000000000000174451306035727200201470ustar00rootroot00000000000000// 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 "raw" containers. package raw import ( "fmt" "github.com/google/cadvisor/container" "github.com/google/cadvisor/container/common" "github.com/google/cadvisor/container/libcontainer" "github.com/google/cadvisor/fs" info "github.com/google/cadvisor/info/v1" "github.com/google/cadvisor/machine" "github.com/golang/glog" "github.com/opencontainers/runc/libcontainer/cgroups" cgroupfs "github.com/opencontainers/runc/libcontainer/cgroups/fs" "github.com/opencontainers/runc/libcontainer/configs" ) type rawContainerHandler struct { // Name of the container for this handler. name string cgroupSubsystems *libcontainer.CgroupSubsystems machineInfoFactory info.MachineInfoFactory // Absolute path to the cgroup hierarchies of this container. // (e.g.: "cpu" -> "/sys/fs/cgroup/cpu/test") cgroupPaths map[string]string // Manager of this container's cgroups. cgroupManager cgroups.Manager fsInfo fs.FsInfo externalMounts []common.Mount rootFs string // Metrics to be ignored. ignoreMetrics container.MetricSet pid int } func isRootCgroup(name string) bool { return name == "/" } func newRawContainerHandler(name string, cgroupSubsystems *libcontainer.CgroupSubsystems, machineInfoFactory info.MachineInfoFactory, fsInfo fs.FsInfo, watcher *common.InotifyWatcher, rootFs string, ignoreMetrics container.MetricSet) (container.ContainerHandler, error) { cgroupPaths := common.MakeCgroupPaths(cgroupSubsystems.MountPoints, name) cHints, err := common.GetContainerHintsFromFile(*common.ArgContainerHints) if err != nil { return nil, err } // Generate the equivalent cgroup manager for this container. cgroupManager := &cgroupfs.Manager{ Cgroups: &configs.Cgroup{ Name: name, }, Paths: cgroupPaths, } var externalMounts []common.Mount for _, container := range cHints.AllHosts { if name == container.FullName { externalMounts = container.Mounts break } } pid := 0 if isRootCgroup(name) { pid = 1 } return &rawContainerHandler{ name: name, cgroupSubsystems: cgroupSubsystems, machineInfoFactory: machineInfoFactory, cgroupPaths: cgroupPaths, cgroupManager: cgroupManager, fsInfo: fsInfo, externalMounts: externalMounts, rootFs: rootFs, ignoreMetrics: ignoreMetrics, pid: pid, }, nil } func (self *rawContainerHandler) ContainerReference() (info.ContainerReference, error) { // We only know the container by its one name. return info.ContainerReference{ Name: self.name, }, nil } func (self *rawContainerHandler) GetRootNetworkDevices() ([]info.NetInfo, error) { nd := []info.NetInfo{} if isRootCgroup(self.name) { mi, err := self.machineInfoFactory.GetMachineInfo() if err != nil { return nd, err } return mi.NetworkDevices, nil } return nd, nil } // Nothing to start up. func (self *rawContainerHandler) Start() {} // Nothing to clean up. func (self *rawContainerHandler) Cleanup() {} func (self *rawContainerHandler) GetSpec() (info.ContainerSpec, error) { const hasNetwork = false hasFilesystem := isRootCgroup(self.name) || len(self.externalMounts) > 0 spec, err := common.GetSpec(self.cgroupPaths, self.machineInfoFactory, hasNetwork, hasFilesystem) if err != nil { return spec, err } if isRootCgroup(self.name) { // Check physical network devices for root container. nd, err := self.GetRootNetworkDevices() if err != nil { return spec, err } spec.HasNetwork = spec.HasNetwork || len(nd) != 0 // Get memory and swap limits of the running machine memLimit, err := machine.GetMachineMemoryCapacity() if err != nil { glog.Warningf("failed to obtain memory limit for machine container") spec.HasMemory = false } else { spec.Memory.Limit = uint64(memLimit) // Spec is marked to have memory only if the memory limit is set spec.HasMemory = true } swapLimit, err := machine.GetMachineSwapCapacity() if err != nil { glog.Warningf("failed to obtain swap limit for machine container") } else { spec.Memory.SwapLimit = uint64(swapLimit) } } return spec, nil } func fsToFsStats(fs *fs.Fs) info.FsStats { inodes := uint64(0) inodesFree := uint64(0) hasInodes := fs.InodesFree != nil if hasInodes { inodes = *fs.Inodes inodesFree = *fs.InodesFree } return info.FsStats{ Device: fs.Device, Type: fs.Type.String(), Limit: fs.Capacity, Usage: fs.Capacity - fs.Free, HasInodes: hasInodes, Inodes: inodes, InodesFree: inodesFree, Available: fs.Available, ReadsCompleted: fs.DiskStats.ReadsCompleted, ReadsMerged: fs.DiskStats.ReadsMerged, SectorsRead: fs.DiskStats.SectorsRead, ReadTime: fs.DiskStats.ReadTime, WritesCompleted: fs.DiskStats.WritesCompleted, WritesMerged: fs.DiskStats.WritesMerged, SectorsWritten: fs.DiskStats.SectorsWritten, WriteTime: fs.DiskStats.WriteTime, IoInProgress: fs.DiskStats.IoInProgress, IoTime: fs.DiskStats.IoTime, WeightedIoTime: fs.DiskStats.WeightedIoTime, } } func (self *rawContainerHandler) getFsStats(stats *info.ContainerStats) error { // Get Filesystem information only for the root cgroup. if isRootCgroup(self.name) { filesystems, err := self.fsInfo.GetGlobalFsInfo() if err != nil { return err } for i := range filesystems { fs := filesystems[i] stats.Filesystem = append(stats.Filesystem, fsToFsStats(&fs)) } } else if len(self.externalMounts) > 0 { var mountSet map[string]struct{} mountSet = make(map[string]struct{}) for _, mount := range self.externalMounts { mountSet[mount.HostDir] = struct{}{} } filesystems, err := self.fsInfo.GetFsInfoForPath(mountSet) if err != nil { return err } for i := range filesystems { fs := filesystems[i] stats.Filesystem = append(stats.Filesystem, fsToFsStats(&fs)) } } return nil } func (self *rawContainerHandler) GetStats() (*info.ContainerStats, error) { stats, err := libcontainer.GetStats(self.cgroupManager, self.rootFs, self.pid, self.ignoreMetrics) if err != nil { return stats, err } // Get filesystem stats. err = self.getFsStats(stats) if err != nil { return stats, err } return stats, nil } func (self *rawContainerHandler) GetCgroupPath(resource string) (string, error) { path, ok := self.cgroupPaths[resource] if !ok { return "", fmt.Errorf("could not find path for resource %q for container %q\n", resource, self.name) } return path, nil } func (self *rawContainerHandler) GetContainerLabels() map[string]string { return map[string]string{} } func (self *rawContainerHandler) GetContainerIPAddress() string { // the IP address for the raw container corresponds to the system ip address. return "127.0.0.1" } func (self *rawContainerHandler) ListContainers(listType container.ListType) ([]info.ContainerReference, error) { return common.ListContainers(self.name, self.cgroupPaths, listType) } func (self *rawContainerHandler) ListProcesses(listType container.ListType) ([]int, error) { return libcontainer.GetProcesses(self.cgroupManager) } func (self *rawContainerHandler) Exists() bool { return common.CgroupExists(self.cgroupPaths) } func (self *rawContainerHandler) Type() container.ContainerType { return container.ContainerTypeRaw } cadvisor-0.25.0/container/raw/handler_test.go000066400000000000000000000073731306035727200212050ustar00rootroot00000000000000// Copyright 2016 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Handler for "raw" containers. package raw import ( "reflect" "testing" "github.com/google/cadvisor/fs" info "github.com/google/cadvisor/info/v1" ) func TestFsToFsStats(t *testing.T) { inodes := uint64(100) inodesFree := uint64(50) testCases := map[string]struct { fs *fs.Fs expected info.FsStats }{ "has_inodes": { fs: &fs.Fs{ DeviceInfo: fs.DeviceInfo{Device: "123"}, Type: fs.VFS, Capacity: uint64(1024 * 1024), Free: uint64(1024), Available: uint64(1024), Inodes: &inodes, InodesFree: &inodesFree, DiskStats: fs.DiskStats{ ReadsCompleted: uint64(100), ReadsMerged: uint64(100), SectorsRead: uint64(100), ReadTime: uint64(100), WritesCompleted: uint64(100), WritesMerged: uint64(100), SectorsWritten: uint64(100), WriteTime: uint64(100), IoInProgress: uint64(100), IoTime: uint64(100), WeightedIoTime: uint64(100), }, }, expected: info.FsStats{ Device: "123", Type: fs.VFS.String(), Limit: uint64(1024 * 1024), Usage: uint64(1024*1024) - uint64(1024), HasInodes: true, Inodes: inodes, InodesFree: inodesFree, Available: uint64(1024), ReadsCompleted: uint64(100), ReadsMerged: uint64(100), SectorsRead: uint64(100), ReadTime: uint64(100), WritesCompleted: uint64(100), WritesMerged: uint64(100), SectorsWritten: uint64(100), WriteTime: uint64(100), IoInProgress: uint64(100), IoTime: uint64(100), WeightedIoTime: uint64(100), }, }, "has_no_inodes": { fs: &fs.Fs{ DeviceInfo: fs.DeviceInfo{Device: "123"}, Type: fs.DeviceMapper, Capacity: uint64(1024 * 1024), Free: uint64(1024), Available: uint64(1024), DiskStats: fs.DiskStats{ ReadsCompleted: uint64(100), ReadsMerged: uint64(100), SectorsRead: uint64(100), ReadTime: uint64(100), WritesCompleted: uint64(100), WritesMerged: uint64(100), SectorsWritten: uint64(100), WriteTime: uint64(100), IoInProgress: uint64(100), IoTime: uint64(100), WeightedIoTime: uint64(100), }, }, expected: info.FsStats{ Device: "123", Type: fs.DeviceMapper.String(), Limit: uint64(1024 * 1024), Usage: uint64(1024*1024) - uint64(1024), HasInodes: false, Available: uint64(1024), ReadsCompleted: uint64(100), ReadsMerged: uint64(100), SectorsRead: uint64(100), ReadTime: uint64(100), WritesCompleted: uint64(100), WritesMerged: uint64(100), SectorsWritten: uint64(100), WriteTime: uint64(100), IoInProgress: uint64(100), IoTime: uint64(100), WeightedIoTime: uint64(100), }, }, } for testName, testCase := range testCases { actual := fsToFsStats(testCase.fs) if !reflect.DeepEqual(testCase.expected, actual) { t.Errorf("test case=%v, expected=%v, actual=%v", testName, testCase.expected, actual) } } } cadvisor-0.25.0/container/rkt/000077500000000000000000000000001306035727200161775ustar00rootroot00000000000000cadvisor-0.25.0/container/rkt/client.go000066400000000000000000000047061306035727200200130ustar00rootroot00000000000000// Copyright 2016 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package rkt import ( "fmt" "net" "sync" "time" "github.com/blang/semver" rktapi "github.com/coreos/rkt/api/v1alpha" "golang.org/x/net/context" "google.golang.org/grpc" ) const ( defaultRktAPIServiceAddr = "localhost:15441" timeout = 2 * time.Second minimumRktBinVersion = "1.6.0" ) var ( rktClient rktapi.PublicAPIClient rktClientErr error once sync.Once ) func Client() (rktapi.PublicAPIClient, error) { once.Do(func() { conn, err := net.DialTimeout("tcp", defaultRktAPIServiceAddr, timeout) if err != nil { rktClient = nil rktClientErr = fmt.Errorf("rkt: cannot tcp Dial rkt api service: %v", err) return } conn.Close() apisvcConn, err := grpc.Dial(defaultRktAPIServiceAddr, grpc.WithInsecure(), grpc.WithTimeout(timeout)) if err != nil { rktClient = nil rktClientErr = fmt.Errorf("rkt: cannot grpc Dial rkt api service: %v", err) return } apisvc := rktapi.NewPublicAPIClient(apisvcConn) resp, err := apisvc.GetInfo(context.Background(), &rktapi.GetInfoRequest{}) if err != nil { rktClientErr = fmt.Errorf("rkt: GetInfo() failed: %v", err) return } binVersion, err := semver.Make(resp.Info.RktVersion) if err != nil { rktClientErr = fmt.Errorf("rkt: couldn't parse RtVersion: %v", err) return } if binVersion.LT(semver.MustParse(minimumRktBinVersion)) { rktClientErr = fmt.Errorf("rkt: binary version is too old(%v), requires at least %v", resp.Info.RktVersion, minimumRktBinVersion) return } rktClient = apisvc }) return rktClient, rktClientErr } func RktPath() (string, error) { client, err := Client() if err != nil { return "", err } resp, err := client.GetInfo(context.Background(), &rktapi.GetInfoRequest{}) if err != nil { return "", fmt.Errorf("couldn't GetInfo from rkt api service: %v", err) } return resp.Info.GlobalFlags.Dir, nil } cadvisor-0.25.0/container/rkt/client_test.go000066400000000000000000000015401306035727200210430ustar00rootroot00000000000000// Copyright 2016 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package rkt import ( "testing" "github.com/blang/semver" ) func TestMinParse(t *testing.T) { _, err := semver.Make(minimumRktBinVersion) if err != nil { t.Errorf("Couldn't parse the minimumRktBinVersion(%v): %v", minimumRktBinVersion, err) } } cadvisor-0.25.0/container/rkt/factory.go000066400000000000000000000053241306035727200202010ustar00rootroot00000000000000// Copyright 2016 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package rkt import ( "fmt" "github.com/google/cadvisor/container" "github.com/google/cadvisor/container/libcontainer" "github.com/google/cadvisor/fs" info "github.com/google/cadvisor/info/v1" "github.com/google/cadvisor/manager/watcher" "github.com/golang/glog" ) const RktNamespace = "rkt" type rktFactory struct { machineInfoFactory info.MachineInfoFactory cgroupSubsystems *libcontainer.CgroupSubsystems fsInfo fs.FsInfo ignoreMetrics container.MetricSet rktPath string } func (self *rktFactory) String() string { return "rkt" } func (self *rktFactory) NewContainerHandler(name string, inHostNamespace bool) (container.ContainerHandler, error) { client, err := Client() if err != nil { return nil, err } rootFs := "/" if !inHostNamespace { rootFs = "/rootfs" } return newRktContainerHandler(name, client, self.rktPath, self.cgroupSubsystems, self.machineInfoFactory, self.fsInfo, rootFs, self.ignoreMetrics) } func (self *rktFactory) CanHandleAndAccept(name string) (bool, bool, error) { accept, err := verifyPod(name) return accept, accept, err } func (self *rktFactory) DebugInfo() map[string][]string { return map[string][]string{} } func Register(machineInfoFactory info.MachineInfoFactory, fsInfo fs.FsInfo, ignoreMetrics container.MetricSet) error { _, err := Client() if err != nil { return fmt.Errorf("unable to communicate with Rkt api service: %v", err) } rktPath, err := RktPath() if err != nil { return fmt.Errorf("unable to get the RktPath variable %v", err) } cgroupSubsystems, err := libcontainer.GetCgroupSubsystems() if err != nil { return fmt.Errorf("failed to get cgroup subsystems: %v", err) } if len(cgroupSubsystems.Mounts) == 0 { return fmt.Errorf("failed to find supported cgroup mounts for the raw factory") } glog.Infof("Registering Rkt factory") factory := &rktFactory{ machineInfoFactory: machineInfoFactory, fsInfo: fsInfo, cgroupSubsystems: &cgroupSubsystems, ignoreMetrics: ignoreMetrics, rktPath: rktPath, } container.RegisterContainerHandlerFactory(factory, []watcher.ContainerWatchSource{watcher.Rkt}) return nil } cadvisor-0.25.0/container/rkt/handler.go000066400000000000000000000200111306035727200201350ustar00rootroot00000000000000// Copyright 2016 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Handler for "rkt" containers. package rkt import ( "fmt" "os" rktapi "github.com/coreos/rkt/api/v1alpha" "github.com/google/cadvisor/container" "github.com/google/cadvisor/container/common" "github.com/google/cadvisor/container/libcontainer" "github.com/google/cadvisor/fs" info "github.com/google/cadvisor/info/v1" "golang.org/x/net/context" "github.com/golang/glog" "github.com/opencontainers/runc/libcontainer/cgroups" cgroupfs "github.com/opencontainers/runc/libcontainer/cgroups/fs" "github.com/opencontainers/runc/libcontainer/configs" ) type rktContainerHandler struct { rktClient rktapi.PublicAPIClient // Name of the container for this handler. name string cgroupSubsystems *libcontainer.CgroupSubsystems machineInfoFactory info.MachineInfoFactory // Absolute path to the cgroup hierarchies of this container. // (e.g.: "cpu" -> "/sys/fs/cgroup/cpu/test") cgroupPaths map[string]string // Manager of this container's cgroups. cgroupManager cgroups.Manager // Whether this container has network isolation enabled. hasNetwork bool fsInfo fs.FsInfo rootFs string isPod bool aliases []string pid int rootfsStorageDir string labels map[string]string // Filesystem handler. fsHandler common.FsHandler ignoreMetrics container.MetricSet apiPod *rktapi.Pod } func newRktContainerHandler(name string, rktClient rktapi.PublicAPIClient, rktPath string, cgroupSubsystems *libcontainer.CgroupSubsystems, machineInfoFactory info.MachineInfoFactory, fsInfo fs.FsInfo, rootFs string, ignoreMetrics container.MetricSet) (container.ContainerHandler, error) { aliases := make([]string, 1) isPod := false apiPod := &rktapi.Pod{} parsed, err := parseName(name) if err != nil { return nil, fmt.Errorf("this should be impossible!, new handler failing, but factory allowed, name = %s", name) } // rktnetes uses containerID: rkt://fff40827-b994-4e3a-8f88-6427c2c8a5ac:nginx if parsed.Container == "" { isPod = true aliases = append(aliases, "rkt://"+parsed.Pod) } else { aliases = append(aliases, "rkt://"+parsed.Pod+":"+parsed.Container) } pid := os.Getpid() labels := make(map[string]string) resp, err := rktClient.InspectPod(context.Background(), &rktapi.InspectPodRequest{ Id: parsed.Pod, }) if err != nil { return nil, err } annotations := resp.Pod.Annotations if parsed.Container != "" { // As not empty string, an App container if contAnnotations, ok := findAnnotations(resp.Pod.Apps, parsed.Container); !ok { glog.Warningf("couldn't find app %v in pod", parsed.Container) } else { annotations = append(annotations, contAnnotations...) } } else { // The Pod container pid = int(resp.Pod.Pid) apiPod = resp.Pod } labels = createLabels(annotations) cgroupPaths := common.MakeCgroupPaths(cgroupSubsystems.MountPoints, name) // Generate the equivalent cgroup manager for this container. cgroupManager := &cgroupfs.Manager{ Cgroups: &configs.Cgroup{ Name: name, }, Paths: cgroupPaths, } hasNetwork := false if isPod { hasNetwork = true } rootfsStorageDir := getRootFs(rktPath, parsed) handler := &rktContainerHandler{ name: name, rktClient: rktClient, cgroupSubsystems: cgroupSubsystems, machineInfoFactory: machineInfoFactory, cgroupPaths: cgroupPaths, cgroupManager: cgroupManager, fsInfo: fsInfo, hasNetwork: hasNetwork, rootFs: rootFs, isPod: isPod, aliases: aliases, pid: pid, labels: labels, rootfsStorageDir: rootfsStorageDir, ignoreMetrics: ignoreMetrics, apiPod: apiPod, } if !ignoreMetrics.Has(container.DiskUsageMetrics) { handler.fsHandler = common.NewFsHandler(common.DefaultPeriod, rootfsStorageDir, "", fsInfo) } return handler, nil } func findAnnotations(apps []*rktapi.App, container string) ([]*rktapi.KeyValue, bool) { for _, app := range apps { if app.Name == container { return app.Annotations, true } } return nil, false } func createLabels(annotations []*rktapi.KeyValue) map[string]string { labels := make(map[string]string) for _, kv := range annotations { labels[kv.Key] = kv.Value } return labels } func (handler *rktContainerHandler) ContainerReference() (info.ContainerReference, error) { return info.ContainerReference{ Name: handler.name, Aliases: handler.aliases, Namespace: RktNamespace, Labels: handler.labels, }, nil } func (handler *rktContainerHandler) Start() { handler.fsHandler.Start() } func (handler *rktContainerHandler) Cleanup() { handler.fsHandler.Stop() } func (handler *rktContainerHandler) GetSpec() (info.ContainerSpec, error) { hasNetwork := handler.hasNetwork && !handler.ignoreMetrics.Has(container.NetworkUsageMetrics) hasFilesystem := !handler.ignoreMetrics.Has(container.DiskUsageMetrics) spec, err := common.GetSpec(handler.cgroupPaths, handler.machineInfoFactory, hasNetwork, hasFilesystem) spec.Labels = handler.labels return spec, err } func (handler *rktContainerHandler) getFsStats(stats *info.ContainerStats) error { if handler.ignoreMetrics.Has(container.DiskUsageMetrics) { return nil } deviceInfo, err := handler.fsInfo.GetDirFsDevice(handler.rootfsStorageDir) if err != nil { return err } mi, err := handler.machineInfoFactory.GetMachineInfo() if err != nil { return err } var limit uint64 = 0 // Use capacity as limit. for _, fs := range mi.Filesystems { if fs.Device == deviceInfo.Device { limit = fs.Capacity break } } fsStat := info.FsStats{Device: deviceInfo.Device, Limit: limit} usage := handler.fsHandler.Usage() fsStat.BaseUsage = usage.BaseUsageBytes fsStat.Usage = usage.TotalUsageBytes fsStat.Inodes = usage.InodeUsage stats.Filesystem = append(stats.Filesystem, fsStat) return nil } func (handler *rktContainerHandler) GetStats() (*info.ContainerStats, error) { stats, err := libcontainer.GetStats(handler.cgroupManager, handler.rootFs, handler.pid, handler.ignoreMetrics) if err != nil { return stats, err } // Get filesystem stats. err = handler.getFsStats(stats) if err != nil { return stats, err } return stats, nil } func (self *rktContainerHandler) GetContainerIPAddress() string { // attempt to return the ip address of the pod // if a specific ip address of the pod could not be determined, return the system ip address if self.isPod && len(self.apiPod.Networks) > 0 { address := self.apiPod.Networks[0].Ipv4 if address != "" { return address } else { return self.apiPod.Networks[0].Ipv6 } } else { return "127.0.0.1" } } func (handler *rktContainerHandler) GetCgroupPath(resource string) (string, error) { path, ok := handler.cgroupPaths[resource] if !ok { return "", fmt.Errorf("could not find path for resource %q for container %q\n", resource, handler.name) } return path, nil } func (handler *rktContainerHandler) GetContainerLabels() map[string]string { return handler.labels } func (handler *rktContainerHandler) ListContainers(listType container.ListType) ([]info.ContainerReference, error) { return common.ListContainers(handler.name, handler.cgroupPaths, listType) } func (handler *rktContainerHandler) ListProcesses(listType container.ListType) ([]int, error) { return libcontainer.GetProcesses(handler.cgroupManager) } func (handler *rktContainerHandler) Exists() bool { return common.CgroupExists(handler.cgroupPaths) } func (handler *rktContainerHandler) Type() container.ContainerType { return container.ContainerTypeRkt } cadvisor-0.25.0/container/rkt/helpers.go000066400000000000000000000075741306035727200202050ustar00rootroot00000000000000// Copyright 2016 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package rkt import ( "fmt" "io/ioutil" "path" "strings" rktapi "github.com/coreos/rkt/api/v1alpha" "github.com/golang/glog" "golang.org/x/net/context" ) type parsedName struct { Pod string Container string } func verifyPod(name string) (bool, error) { pod, err := cgroupToPod(name) if err != nil || pod == nil { return false, err } // Anything handler can handle is also accepted. // Accept cgroups that are sub the pod cgroup, except "system.slice" // - "system.slice" doesn't contain any processes itself accept := !strings.HasSuffix(name, "/system.slice") return accept, nil } func cgroupToPod(name string) (*rktapi.Pod, error) { rktClient, err := Client() if err != nil { return nil, fmt.Errorf("couldn't get rkt api service: %v", err) } resp, err := rktClient.ListPods(context.Background(), &rktapi.ListPodsRequest{ Filters: []*rktapi.PodFilter{ { States: []rktapi.PodState{rktapi.PodState_POD_STATE_RUNNING}, PodSubCgroups: []string{name}, }, }, }) if err != nil { return nil, fmt.Errorf("failed to list pods: %v", err) } if len(resp.Pods) == 0 { return nil, nil } if len(resp.Pods) != 1 { return nil, fmt.Errorf("returned %d (expected 1) pods for cgroup %v", len(resp.Pods), name) } return resp.Pods[0], nil } /* Parse cgroup name into a pod/container name struct Example cgroup fs name pod - /machine.slice/machine-rkt\\x2df556b64a\\x2d17a7\\x2d47d7\\x2d93ec\\x2def2275c3d67e.scope/ or /system.slice/k8s-..../ container under pod - /machine.slice/machine-rkt\\x2df556b64a\\x2d17a7\\x2d47d7\\x2d93ec\\x2def2275c3d67e.scope/system.slice/alpine-sh.service or /system.slice/k8s-..../system.slice/pause.service */ func parseName(name string) (*parsedName, error) { pod, err := cgroupToPod(name) if err != nil { return nil, fmt.Errorf("parseName: couldn't convert %v to a rkt pod: %v", name, err) } if pod == nil { return nil, fmt.Errorf("parseName: didn't return a pod for %v", name) } splits := strings.Split(name, "/") parsed := &parsedName{} if len(splits) == 3 || len(splits) == 5 { parsed.Pod = pod.Id if len(splits) == 5 { parsed.Container = strings.Replace(splits[4], ".service", "", -1) } return parsed, nil } return nil, fmt.Errorf("%s not handled by rkt handler", name) } // Gets a Rkt container's overlay upper dir func getRootFs(root string, parsed *parsedName) string { /* Example of where it stores the upper dir key for container /var/lib/rkt/pods/run/bc793ec6-c48f-4480-99b5-6bec16d52210/appsinfo/alpine-sh/treeStoreID for pod /var/lib/rkt/pods/run/f556b64a-17a7-47d7-93ec-ef2275c3d67e/stage1TreeStoreID */ var tree string if parsed.Container == "" { tree = path.Join(root, "pods/run", parsed.Pod, "stage1TreeStoreID") } else { tree = path.Join(root, "pods/run", parsed.Pod, "appsinfo", parsed.Container, "treeStoreID") } bytes, err := ioutil.ReadFile(tree) if err != nil { glog.Errorf("ReadFile failed, couldn't read %v to get upper dir: %v", tree, err) return "" } s := string(bytes) /* Example of where the upper dir is stored via key read above /var/lib/rkt/pods/run/bc793ec6-c48f-4480-99b5-6bec16d52210/overlay/deps-sha512-82a099e560a596662b15dec835e9adabab539cad1f41776a30195a01a8f2f22b/ */ return path.Join(root, "pods/run", parsed.Pod, "overlay", s) } cadvisor-0.25.0/container/systemd/000077500000000000000000000000001306035727200170675ustar00rootroot00000000000000cadvisor-0.25.0/container/systemd/factory.go000066400000000000000000000036721306035727200210750ustar00rootroot00000000000000// Copyright 2016 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package systemd import ( "fmt" "strings" "github.com/google/cadvisor/container" "github.com/google/cadvisor/fs" info "github.com/google/cadvisor/info/v1" "github.com/google/cadvisor/manager/watcher" "github.com/golang/glog" ) type systemdFactory struct{} func (f *systemdFactory) String() string { return "systemd" } func (f *systemdFactory) NewContainerHandler(name string, inHostNamespace bool) (container.ContainerHandler, error) { return nil, fmt.Errorf("Not yet supported") } func (f *systemdFactory) CanHandleAndAccept(name string) (bool, bool, error) { // on systemd using devicemapper each mount into the container has an associated cgroup that we ignore. // for details on .mount units: http://man7.org/linux/man-pages/man5/systemd.mount.5.html if strings.HasSuffix(name, ".mount") { return true, false, nil } return false, false, fmt.Errorf("%s not handled by systemd handler", name) } func (f *systemdFactory) DebugInfo() map[string][]string { return map[string][]string{} } // Register registers the systemd container factory. func Register(machineInfoFactory info.MachineInfoFactory, fsInfo fs.FsInfo, ignoreMetrics container.MetricSet) error { glog.Infof("Registering systemd factory") factory := &systemdFactory{} container.RegisterContainerHandlerFactory(factory, []watcher.ContainerWatchSource{watcher.Raw}) return nil } cadvisor-0.25.0/container/testing/000077500000000000000000000000001306035727200170545ustar00rootroot00000000000000cadvisor-0.25.0/container/testing/mock_handler.go000066400000000000000000000071471306035727200220420ustar00rootroot00000000000000// 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 testing import ( "github.com/google/cadvisor/container" info "github.com/google/cadvisor/info/v1" "github.com/stretchr/testify/mock" ) // This struct mocks a container handler. type MockContainerHandler struct { mock.Mock Name string Aliases []string } func NewMockContainerHandler(containerName string) *MockContainerHandler { return &MockContainerHandler{ Name: containerName, } } // If self.Name is not empty, then ContainerReference() will return self.Name and self.Aliases. // Otherwise, it will use the value provided by .On().Return(). func (self *MockContainerHandler) ContainerReference() (info.ContainerReference, error) { if len(self.Name) > 0 { var aliases []string if len(self.Aliases) > 0 { aliases = make([]string, len(self.Aliases)) copy(aliases, self.Aliases) } return info.ContainerReference{ Name: self.Name, Aliases: aliases, }, nil } args := self.Called() return args.Get(0).(info.ContainerReference), args.Error(1) } func (self *MockContainerHandler) Start() {} func (self *MockContainerHandler) Cleanup() {} func (self *MockContainerHandler) GetSpec() (info.ContainerSpec, error) { args := self.Called() return args.Get(0).(info.ContainerSpec), 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 container.ListType) ([]info.ContainerReference, error) { args := self.Called(listType) return args.Get(0).([]info.ContainerReference), args.Error(1) } func (self *MockContainerHandler) ListProcesses(listType container.ListType) ([]int, error) { args := self.Called(listType) return args.Get(0).([]int), args.Error(1) } func (self *MockContainerHandler) Exists() bool { args := self.Called() return args.Get(0).(bool) } func (self *MockContainerHandler) GetCgroupPath(path string) (string, error) { args := self.Called(path) return args.Get(0).(string), args.Error(1) } func (self *MockContainerHandler) GetContainerLabels() map[string]string { args := self.Called() return args.Get(0).(map[string]string) } func (self *MockContainerHandler) Type() container.ContainerType { args := self.Called() return args.Get(0).(container.ContainerType) } func (self *MockContainerHandler) GetContainerIPAddress() string { args := self.Called() return args.Get(0).(string) } type FactoryForMockContainerHandler struct { Name string PrepareContainerHandlerFunc func(name string, handler *MockContainerHandler) } func (self *FactoryForMockContainerHandler) String() string { return self.Name } func (self *FactoryForMockContainerHandler) NewContainerHandler(name string, inHostNamespace bool) (container.ContainerHandler, error) { handler := &MockContainerHandler{} if self.PrepareContainerHandlerFunc != nil { self.PrepareContainerHandlerFunc(name, handler) } return handler, nil } func (self *FactoryForMockContainerHandler) CanHandle(name string) bool { return true } cadvisor-0.25.0/deploy/000077500000000000000000000000001306035727200147115ustar00rootroot00000000000000cadvisor-0.25.0/deploy/Dockerfile000066400000000000000000000022661306035727200167110ustar00rootroot00000000000000FROM alpine:3.4 MAINTAINER dengnan@google.com vmarmol@google.com vishnuk@google.com jimmidyson@gmail.com stclair@google.com ENV GLIBC_VERSION "2.23-r3" RUN apk --no-cache add ca-certificates wget device-mapper && \ apk --no-cache add zfs --repository http://dl-3.alpinelinux.org/alpine/edge/main/ && \ apk --no-cache add thin-provisioning-tools --repository http://dl-3.alpinelinux.org/alpine/edge/testing/ && \ wget -q -O /etc/apk/keys/sgerrand.rsa.pub https://raw.githubusercontent.com/sgerrand/alpine-pkg-glibc/master/sgerrand.rsa.pub && \ wget https://github.com/sgerrand/alpine-pkg-glibc/releases/download/${GLIBC_VERSION}/glibc-${GLIBC_VERSION}.apk && \ wget https://github.com/andyshinn/alpine-pkg-glibc/releases/download/${GLIBC_VERSION}/glibc-bin-${GLIBC_VERSION}.apk && \ apk add glibc-${GLIBC_VERSION}.apk glibc-bin-${GLIBC_VERSION}.apk && \ /usr/glibc-compat/sbin/ldconfig /lib /usr/glibc-compat/lib && \ echo 'hosts: files mdns4_minimal [NOTFOUND=return] dns mdns4' >> /etc/nsswitch.conf && \ rm -rf /var/cache/apk/* # Grab cadvisor from the staging directory. ADD cadvisor /usr/bin/cadvisor EXPOSE 8080 ENTRYPOINT ["/usr/bin/cadvisor", "-logtostderr"] cadvisor-0.25.0/deploy/build.sh000077500000000000000000000012441306035727200163500ustar00rootroot00000000000000#!/bin/bash # Copyright 2015 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. set -e set -x make build docker build -t google/cadvisor:beta . cadvisor-0.25.0/deploy/canary/000077500000000000000000000000001306035727200161665ustar00rootroot00000000000000cadvisor-0.25.0/deploy/canary/Dockerfile000066400000000000000000000004341306035727200201610ustar00rootroot00000000000000FROM golang:latest MAINTAINER vmarmol@google.com RUN apt-get install -y git dmsetup RUN git clone https://github.com/google/cadvisor.git /go/src/github.com/google/cadvisor RUN cd /go/src/github.com/google/cadvisor && make ENTRYPOINT ["/go/src/github.com/google/cadvisor/cadvisor"] cadvisor-0.25.0/devicemapper/000077500000000000000000000000001306035727200160615ustar00rootroot00000000000000cadvisor-0.25.0/devicemapper/dmsetup_client.go000066400000000000000000000043011306035727200214250ustar00rootroot00000000000000// Copyright 2016 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package devicemapper import ( "os/exec" "strconv" "strings" "github.com/golang/glog" ) // DmsetupClient is a low-level client for interacting with device mapper via // the `dmsetup` utility, which is provided by the `device-mapper` package. type DmsetupClient interface { // Table runs `dmsetup table` on the given device name and returns the // output or an error. Table(deviceName string) ([]byte, error) // Message runs `dmsetup message` on the given device, passing the given // message to the given sector, and returns the output or an error. Message(deviceName string, sector int, message string) ([]byte, error) // Status runs `dmsetup status` on the given device and returns the output // or an error. Status(deviceName string) ([]byte, error) } // NewDmSetupClient returns a new DmsetupClient. func NewDmsetupClient() DmsetupClient { return &defaultDmsetupClient{} } // defaultDmsetupClient is a functional DmsetupClient type defaultDmsetupClient struct{} var _ DmsetupClient = &defaultDmsetupClient{} func (c *defaultDmsetupClient) Table(deviceName string) ([]byte, error) { return c.dmsetup("table", deviceName) } func (c *defaultDmsetupClient) Message(deviceName string, sector int, message string) ([]byte, error) { return c.dmsetup("message", deviceName, strconv.Itoa(sector), message) } func (c *defaultDmsetupClient) Status(deviceName string) ([]byte, error) { return c.dmsetup("status", deviceName) } func (*defaultDmsetupClient) dmsetup(args ...string) ([]byte, error) { glog.V(5).Infof("running dmsetup %v", strings.Join(args, " ")) return exec.Command("dmsetup", args...).Output() } cadvisor-0.25.0/devicemapper/doc.go000066400000000000000000000012731306035727200171600ustar00rootroot00000000000000// Copyright 2016 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Package devicemapper contains code for working with devicemapper package devicemapper cadvisor-0.25.0/devicemapper/fake/000077500000000000000000000000001306035727200167675ustar00rootroot00000000000000cadvisor-0.25.0/devicemapper/fake/dmsetup_client_fake.go000066400000000000000000000040151306035727200233230ustar00rootroot00000000000000// Copyright 2016 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package fake import ( "testing" ) type DmsetupCommand struct { Name string Result string Err error } // NewFakeDmsetupClient returns a new fake DmsetupClient. func NewFakeDmsetupClient(t *testing.T, commands ...DmsetupCommand) *FakeDmsetupClient { if len(commands) == 0 { commands = make([]DmsetupCommand, 0) } return &FakeDmsetupClient{t: t, commands: commands} } // FakeDmsetupClient is a thread-unsafe fake implementation of the // DmsetupClient interface type FakeDmsetupClient struct { t *testing.T commands []DmsetupCommand } func (c *FakeDmsetupClient) Table(deviceName string) ([]byte, error) { return c.dmsetup("table") } func (c *FakeDmsetupClient) Message(deviceName string, sector int, message string) ([]byte, error) { return c.dmsetup("message") } func (c *FakeDmsetupClient) Status(deviceName string) ([]byte, error) { return c.dmsetup("status") } func (c *FakeDmsetupClient) AddCommand(name string, result string, err error) { c.commands = append(c.commands, DmsetupCommand{name, result, err}) } func (c *FakeDmsetupClient) dmsetup(inputCommand string) ([]byte, error) { var nextCommand DmsetupCommand nextCommand, c.commands = c.commands[0], c.commands[1:] if nextCommand.Name != inputCommand { c.t.Fatalf("unexpected dmsetup command; expected: %q, got %q", nextCommand.Name, inputCommand) // should be unreachable in a test context. } return []byte(nextCommand.Result), nextCommand.Err } cadvisor-0.25.0/devicemapper/fake/thin_ls_client_fake.go000066400000000000000000000017311306035727200233040ustar00rootroot00000000000000// Copyright 2016 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package fake type FakeThinLsClient struct { result map[string]uint64 err error } // NewFakeThinLsClient returns a new fake ThinLsClient. func NewFakeThinLsClient(result map[string]uint64, err error) *FakeThinLsClient { return &FakeThinLsClient{result, err} } func (c *FakeThinLsClient) ThinLs(deviceName string) (map[string]uint64, error) { return c.result, c.err } cadvisor-0.25.0/devicemapper/thin_ls_client.go000066400000000000000000000051241306035727200214100ustar00rootroot00000000000000// Copyright 2016 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package devicemapper import ( "bufio" "bytes" "fmt" "os/exec" "strconv" "strings" "github.com/golang/glog" ) // thinLsClient knows how to run a thin_ls very specific to CoW usage for // containers. type thinLsClient interface { // ThinLs runs a thin ls on the given device, which is expected to be a // metadata device. The caller must hold the metadata snapshot for the // device. ThinLs(deviceName string) (map[string]uint64, error) } // newThinLsClient returns a thinLsClient or an error if the thin_ls binary // couldn't be located. func newThinLsClient() (thinLsClient, error) { thinLsPath, err := ThinLsBinaryPresent() if err != nil { return nil, fmt.Errorf("error creating thin_ls client: %v", err) } return &defaultThinLsClient{thinLsPath}, nil } // defaultThinLsClient is a functional thinLsClient type defaultThinLsClient struct { thinLsPath string } var _ thinLsClient = &defaultThinLsClient{} func (c *defaultThinLsClient) ThinLs(deviceName string) (map[string]uint64, error) { args := []string{"--no-headers", "-m", "-o", "DEV,EXCLUSIVE_BYTES", deviceName} glog.V(4).Infof("running command: thin_ls %v", strings.Join(args, " ")) output, err := exec.Command(c.thinLsPath, args...).Output() if err != nil { return nil, fmt.Errorf("Error running command `thin_ls %v`: %v\noutput:\n\n%v", strings.Join(args, " "), err, string(output)) } return parseThinLsOutput(output), nil } // parseThinLsOutput parses the output returned by thin_ls to build a map of // device id -> usage. func parseThinLsOutput(output []byte) map[string]uint64 { cache := map[string]uint64{} // parse output scanner := bufio.NewScanner(bytes.NewReader(output)) for scanner.Scan() { output := scanner.Text() fields := strings.Fields(output) if len(fields) != 2 { continue } deviceID := fields[0] usage, err := strconv.ParseUint(fields[1], 10, 64) if err != nil { glog.Warning("unexpected error parsing thin_ls output: %v", err) continue } cache[deviceID] = usage } return cache } cadvisor-0.25.0/devicemapper/thin_ls_client_test.go000066400000000000000000000027451306035727200224550ustar00rootroot00000000000000// Copyright 2016 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package devicemapper import ( "reflect" "testing" ) func TestParseThinLsOutput(t *testing.T) { cases := []struct { name string input string expectedResult map[string]uint64 }{ { name: "ok", input: ` 1 2293760 2 2097152 3 131072 4 2031616`, expectedResult: map[string]uint64{ "1": 2293760, "2": 2097152, "3": 131072, "4": 2031616, }, }, { name: "skip bad rows", input: ` 1 2293760 2 2097152 3 131072ads 4d dsrv 2031616`, expectedResult: map[string]uint64{ "1": 2293760, "2": 2097152, }, }, } for _, tc := range cases { actualResult := parseThinLsOutput([]byte(tc.input)) if e, a := tc.expectedResult, actualResult; !reflect.DeepEqual(e, a) { t.Errorf("%v: unexpected result: expected %+v got %+v", tc.name, e, a) } } } cadvisor-0.25.0/devicemapper/thin_pool_watcher.go000066400000000000000000000125171306035727200221260ustar00rootroot00000000000000// Copyright 2016 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package devicemapper import ( "fmt" "strings" "sync" "time" "github.com/golang/glog" ) // ThinPoolWatcher maintains a cache of device name -> usage stats for a // devicemapper thin-pool using thin_ls. type ThinPoolWatcher struct { poolName string metadataDevice string lock *sync.RWMutex cache map[string]uint64 period time.Duration stopChan chan struct{} dmsetup DmsetupClient thinLsClient thinLsClient } // NewThinPoolWatcher returns a new ThinPoolWatcher for the given devicemapper // thin pool name and metadata device or an error. func NewThinPoolWatcher(poolName, metadataDevice string) (*ThinPoolWatcher, error) { thinLsClient, err := newThinLsClient() if err != nil { return nil, fmt.Errorf("encountered error creating thin_ls client: %v", err) } return &ThinPoolWatcher{poolName: poolName, metadataDevice: metadataDevice, lock: &sync.RWMutex{}, cache: make(map[string]uint64), period: 15 * time.Second, stopChan: make(chan struct{}), dmsetup: NewDmsetupClient(), thinLsClient: thinLsClient, }, nil } // Start starts the ThinPoolWatcher. func (w *ThinPoolWatcher) Start() { err := w.Refresh() if err != nil { glog.Errorf("encountered error refreshing thin pool watcher: %v", err) } for { select { case <-w.stopChan: return case <-time.After(w.period): start := time.Now() err = w.Refresh() if err != nil { glog.Errorf("encountered error refreshing thin pool watcher: %v", err) } // print latency for refresh duration := time.Since(start) glog.V(5).Infof("thin_ls(%d) took %s", start.Unix(), duration) } } } // Stop stops the ThinPoolWatcher. func (w *ThinPoolWatcher) Stop() { close(w.stopChan) } // GetUsage gets the cached usage value of the given device. func (w *ThinPoolWatcher) GetUsage(deviceId string) (uint64, error) { w.lock.RLock() defer w.lock.RUnlock() v, ok := w.cache[deviceId] if !ok { return 0, fmt.Errorf("no cached value for usage of device %v", deviceId) } return v, nil } const ( reserveMetadataMessage = "reserve_metadata_snap" releaseMetadataMessage = "release_metadata_snap" ) // Refresh performs a `thin_ls` of the pool being watched and refreshes the // cached data with the result. func (w *ThinPoolWatcher) Refresh() error { w.lock.Lock() defer w.lock.Unlock() currentlyReserved, err := w.checkReservation(w.poolName) if err != nil { err = fmt.Errorf("error determining whether snapshot is reserved: %v", err) return err } if currentlyReserved { glog.V(5).Infof("metadata for %v is currently reserved; releasing", w.poolName) _, err = w.dmsetup.Message(w.poolName, 0, releaseMetadataMessage) if err != nil { err = fmt.Errorf("error releasing metadata snapshot for %v: %v", w.poolName, err) return err } } glog.V(5).Infof("reserving metadata snapshot for thin-pool %v", w.poolName) // NOTE: "0" in the call below is for the 'sector' argument to 'dmsetup // message'. It's not needed for thin pools. if output, err := w.dmsetup.Message(w.poolName, 0, reserveMetadataMessage); err != nil { err = fmt.Errorf("error reserving metadata for thin-pool %v: %v output: %v", w.poolName, err, string(output)) return err } else { glog.V(5).Infof("reserved metadata snapshot for thin-pool %v", w.poolName) } defer func() { glog.V(5).Infof("releasing metadata snapshot for thin-pool %v", w.poolName) w.dmsetup.Message(w.poolName, 0, releaseMetadataMessage) }() glog.V(5).Infof("running thin_ls on metadata device %v", w.metadataDevice) newCache, err := w.thinLsClient.ThinLs(w.metadataDevice) if err != nil { err = fmt.Errorf("error performing thin_ls on metadata device %v: %v", w.metadataDevice, err) return err } w.cache = newCache return nil } const ( thinPoolDmsetupStatusHeldMetadataRoot = 6 thinPoolDmsetupStatusMinFields = thinPoolDmsetupStatusHeldMetadataRoot + 1 ) // checkReservation checks to see whether the thin device is currently holding // userspace metadata. func (w *ThinPoolWatcher) checkReservation(poolName string) (bool, error) { glog.V(5).Infof("checking whether the thin-pool is holding a metadata snapshot") output, err := w.dmsetup.Status(poolName) if err != nil { return false, err } // we care about the field at fields[thinPoolDmsetupStatusHeldMetadataRoot], // so make sure we get enough fields fields := strings.Fields(string(output)) if len(fields) < thinPoolDmsetupStatusMinFields { return false, fmt.Errorf("unexpected output of dmsetup status command; expected at least %d fields, got %v; output: %v", thinPoolDmsetupStatusMinFields, len(fields), string(output)) } heldMetadataRoot := fields[thinPoolDmsetupStatusHeldMetadataRoot] currentlyReserved := heldMetadataRoot != "-" return currentlyReserved, nil } cadvisor-0.25.0/devicemapper/thin_pool_watcher_test.go000066400000000000000000000150171306035727200231630ustar00rootroot00000000000000// Copyright 2016 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package devicemapper import ( "fmt" "sync" "testing" "time" "github.com/google/cadvisor/devicemapper/fake" ) func TestRefresh(t *testing.T) { usage := map[string]uint64{ "1": 12345, "2": 23456, "3": 34567, } cases := []struct { name string dmsetupCommands []fake.DmsetupCommand thinLsOutput map[string]uint64 thinLsErr error expectedError bool deviceId string expectedUsage uint64 }{ { name: "check reservation fails", dmsetupCommands: []fake.DmsetupCommand{ {"status", "", fmt.Errorf("not gonna work")}, }, expectedError: true, }, { name: "no existing reservation - ok with minimum # of fields", dmsetupCommands: []fake.DmsetupCommand{ {"status", "0 75497472 thin-pool 65 327/524288 14092/589824 -", nil}, // status check {"message", "", nil}, // make reservation {"message", "", nil}, // release reservation }, thinLsOutput: usage, expectedError: false, deviceId: "2", expectedUsage: 23456, }, { name: "no existing reservation - ok", dmsetupCommands: []fake.DmsetupCommand{ {"status", "0 75497472 thin-pool 65 327/524288 14092/589824 - rw no_discard_passdown error_if_no_space - ", nil}, // status check {"message", "", nil}, // make reservation {"message", "", nil}, // release reservation }, thinLsOutput: usage, expectedError: false, deviceId: "2", expectedUsage: 23456, }, { name: "existing reservation - ok", dmsetupCommands: []fake.DmsetupCommand{ // status check {"status", "0 75497472 thin-pool 65 327/524288 14092/589824 39 rw no_discard_passdown error_if_no_space - ", nil}, // release reservation {"message", "", nil}, // make reservation {"message", "", nil}, // release reservation {"message", "", nil}, }, thinLsOutput: usage, expectedError: false, deviceId: "3", expectedUsage: 34567, }, { name: "failure releasing existing reservation", dmsetupCommands: []fake.DmsetupCommand{ // status check {"status", "0 75497472 thin-pool 65 327/524288 14092/589824 39 rw no_discard_passdown error_if_no_space - ", nil}, // release reservation {"message", "", fmt.Errorf("not gonna work")}, }, expectedError: true, }, { name: "failure making reservation", dmsetupCommands: []fake.DmsetupCommand{ // status check {"status", "0 75497472 thin-pool 65 327/524288 14092/589824 39 rw no_discard_passdown error_if_no_space - ", nil}, // release reservation {"message", "", nil}, // make reservation {"message", "", fmt.Errorf("not gonna work")}, }, expectedError: true, }, { name: "failure running thin_ls", dmsetupCommands: []fake.DmsetupCommand{ // status check {"status", "0 75497472 thin-pool 65 327/524288 14092/589824 39 rw no_discard_passdown error_if_no_space - ", nil}, // release reservation {"message", "", nil}, // make reservation {"message", "", nil}, // release reservation {"message", "", nil}, }, thinLsErr: fmt.Errorf("not gonna work"), expectedError: true, }, } for _, tc := range cases { dmsetup := fake.NewFakeDmsetupClient(t, tc.dmsetupCommands...) thinLsClient := fake.NewFakeThinLsClient(tc.thinLsOutput, tc.thinLsErr) watcher := &ThinPoolWatcher{ poolName: "test pool name", metadataDevice: "/dev/mapper/metadata-device", lock: &sync.RWMutex{}, period: 15 * time.Second, stopChan: make(chan struct{}), dmsetup: dmsetup, thinLsClient: thinLsClient, } err := watcher.Refresh() if err != nil { if !tc.expectedError { t.Errorf("%v: unexpected error: %v", tc.name, err) } continue } else if tc.expectedError { t.Errorf("%v: unexpected success", tc.name) continue } actualUsage, err := watcher.GetUsage(tc.deviceId) if err != nil { t.Errorf("%v: device ID not found: %v", tc.deviceId, err) continue } if e, a := tc.expectedUsage, actualUsage; e != a { t.Errorf("%v: actual usage did not match expected usage: expected: %v got: %v", tc.name, e, a) } } } func TestCheckReservation(t *testing.T) { cases := []struct { name string statusResult string statusErr error expectedResult bool expectedErr error }{ { name: "existing reservation 1", statusResult: "0 75497472 thin-pool 65 327/524288 14092/589824 36 rw no_discard_passdown queue_if_no_space - ", expectedResult: true, }, { name: "existing reservation 2", statusResult: "0 12345 thin-pool 65 327/45678 14092/45678 36 rw discard_passdown error_if_no_space needs_check ", expectedResult: true, }, { name: "no reservation 1", statusResult: "0 75497472 thin-pool 65 327/524288 14092/589824 - rw no_discard_passdown error_if_no_space - ", expectedResult: false, }, { name: "no reservation 2", statusResult: "0 75 thin-pool 65 327/12345 14092/589824 - rw no_discard_passdown queue_if_no_space - ", expectedResult: false, }, { name: "no reservation 2", statusResult: "0 75 thin-pool 65 327/12345 14092/589824 - rw no_discard_passdown queue_if_no_space - ", expectedResult: false, }, } for _, tc := range cases { fakeDmsetupClient := fake.NewFakeDmsetupClient(t) fakeDmsetupClient.AddCommand("status", tc.statusResult, tc.statusErr) watcher := &ThinPoolWatcher{dmsetup: fakeDmsetupClient} actualResult, err := watcher.checkReservation("test pool") if err != nil { if tc.expectedErr == nil { t.Errorf("%v: unexpected error running checkReservation: %v", tc.name, err) } } else if tc.expectedErr != nil { t.Errorf("%v: unexpected success running checkReservation", tc.name) } if e, a := tc.expectedResult, actualResult; e != a { t.Errorf("%v: unexpected result from checkReservation: expected: %v got: %v", tc.name, e, a) } } } cadvisor-0.25.0/devicemapper/util.go000066400000000000000000000026341306035727200173720ustar00rootroot00000000000000// Copyright 2016 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package devicemapper import ( "fmt" "os" "path/filepath" ) // ThinLsBinaryPresent returns the location of the thin_ls binary in the mount // namespace cadvisor is running in or an error. The locations checked are: // // - /sbin/ // - /bin/ // - /usr/sbin/ // - /usr/bin/ // // The thin_ls binary is provided by the device-mapper-persistent-data // package. func ThinLsBinaryPresent() (string, error) { var ( thinLsPath string err error ) for _, path := range []string{"/sbin", "/bin", "/usr/sbin/", "/usr/bin"} { // try paths for non-containerized operation // note: thin_ls is most likely a symlink to pdata_tools thinLsPath = filepath.Join(path, "thin_ls") _, err = os.Stat(thinLsPath) if err == nil { return thinLsPath, nil } } return "", fmt.Errorf("unable to find thin_ls binary") } cadvisor-0.25.0/docs/000077500000000000000000000000001306035727200143455ustar00rootroot00000000000000cadvisor-0.25.0/docs/api.md000066400000000000000000000123401306035727200154400ustar00rootroot00000000000000# cAdvisor Remote REST API cAdvisor exposes its raw and processed stats via a versioned remote REST API: `http://:/api//` The current version of the API is `v1.3`. There is a beta release of the `v2.0` API [available](api_v2.md). ## Version 1.3 This version exposes the same endpoints as `v1.2` with one additional read-only endpoint. ### Events The resource name for Docker container information is as follows: `/api/v1.3/events/` Querying the endpoint receives a list of events which are a serialized `Event` JSON objects (found in [info/v1/container.go](../info/v1/container.go)). The endpoint accepts a certain number of query parameters: | Parameter | Description | Default | |-------------------|--------------------------------------------------------------------------------|-------------------| | `start_time` | Start time of events to query (for stream=false) | Beginning of time | | `end_time` | End time of events to query (for stream=false) | Now | | `stream` | Whether to stream new events as they occur. If false returns historical events | false | | `subcontainers` | Whether to also return events for all subcontainers | false | | `max_events` | The max number of events to return (for stream=false) | 10 | | `all_events` | Whether to include all supported event types | false | | `oom_events` | Whether to include OOM events | false | | `oom_kill_events` | Whether to include OOM kill events | false | | `creation_events` | Whether to include container creation events | false | | `deletion_events` | Whether to include container deletion events | false | ## Version 1.2 This version exposes the same endpoints as `v1.1` with one additional read-only endpoint. ### Docker Container Information The resource name for Docker container information is as follows: `/api/v1.2/docker/` The Docker name can be either the UUID or the short name of the container. It returns the information of the specified container(s). The information is returned as a list of serialized `ContainerInfo` JSON objects (found in [info/v1/container.go](../info/v1/container.go)). ## Version 1.1 This version exposes the same endpoints as `v1.0` with one additional read-only endpoint. ### Subcontainer Information The resource name for subcontainer information is as follows: `/api/v1.1/subcontainers/` Where the absolute container name follows the lmctfy naming convention (described bellow). It returns the information of the specified container and all subcontainers (recursively). The information is returned as a list of serialized `ContainerInfo` JSON objects (found in [info/v1/container.go](../info/v1/container.go)). ## 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/` 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/v1/container.go](../info/v1/container.go) ### Machine Information The resource name for machine information is as follows: `/api/vX.Y/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) - Maximum supported CPU frequency (in kHz) - Available filesystems: major, minor numbers and capacity (in bytes) - Network devices: mac addresses, MTU, and speed (if available) - Machine topology: Nodes, cores, threads, per-node memory, and caches The actual object is the marshalled JSON of the `MachineInfo` struct found in [info/v1/machine.go](../info/v1/machine.go) cadvisor-0.25.0/docs/api_v2.md000066400000000000000000000116201306035727200160470ustar00rootroot00000000000000# cAdvisor Remote REST API cAdvisor exposes its raw and processed stats via a versioned remote REST API: `http://:/api//` This document covers the detail of version 2.0. All resources covered in this version are read-only. NOTE: v2.0 is still a work in progress. ## Version information Software version for cAdvisor can be obtained from version endpoint as follows: `/api/v2.0/version` ## Machine Information The resource name for machine information is as follows: `/api/v2.0/machine` The machine information is returned as a JSON object of the `MachineInfo` struct found in [info/v1/machine.go](../info/v1/machine.go) ## Attributes Attributes endpoint provides hardware and software attributes of the running machine. The resource name for attributes is: `/api/v2.0/attributes` Hardware information includes all information covered by machine endpoint. Software information include version of cAdvisor, kernel, docker, and underlying OS. The actual object is the marshalled JSON of the `Attributes` struct found in [info/v2/machine.go](../info/v2/machine.go) ## Container Stats The resource name for container stats information is: `/api/v2.0/stats/` ### Stats request options Stats support following options in the request: - `type`: describes the type of identifier. Supported values are `name`(default) and `docker`. `name` implies that the identifier is an absolute container name. `docker` implies that the identifier is a docker id. - `recursive`: Option to specify if stats for subcontainers of the requested containers should also be reported. Default is false. - `count`: Number of stats samples to be reported. Default is 64. ### Container name When container identifier is of type `name`, the identifier is interpreted as the absolute container name. Naming follows the lmctfy convention. For example: | Container Name | Resource Name | |----------------------|-------------------------------------------| | / | /api/v2.0/containers/ | | /foo | /api/v2.0/containers/foo | | /docker/2c4dee605d22 | /api/v2.0/containers/docker/2c4dee605d22 | Note that the root container (`/`) contains usage for the entire machine. All Docker containers are listed under `/docker`. Also, `type=name` is not required in the examples above as `name` is the default type. ### Docker Containers When container identifier is of type `docker`, the identifier is interpreted as docker id. For example: | Docker container | Resource Name | |----------------------|-------------------------------------------| | All docker containers| /api/v2.0/stats?type=docker&recursive=true| | clever_colden | /api/v2.0/stats/clever_colden?type=docker | | 2c4dee605d22 | /api/v2.0/stats/2c4dee605d22?type=docker | The Docker name can be either the UUID or the short name of the container. It returns the information of the specified container(s). Note that `recursive` is only valid when docker root is specified. It is used to get stats for all docker containers. ### Returned stats The stats information is returned as a JSON object containing a map from container name to list of stat objects. Stat object is the marshalled JSON of the `ContainerStats` struct found in [info/v2/container.go](../info/v2/container.go) ## Container Stats Summary Instead of a list of periodically collected detailed samples, cAdvisor can also provide a summary of stats for a container. It provides the latest collected stats and percentiles (max, average, and 90%ile) values for usage in last minute and hour. (Usage summary for last day exists, but is not currently used.) Unlike the regular stats API, only selected resources are captured by `summary`. Currently it is limited to cpu and memory usage. The resource name for container summary information is: `/api/v2.0/summary/` Additionally, `type` and `recursive` options can be used to describe the identifier type and ask for summary of all subcontainers respectively. The semantics are same as described for container stats above. The returned summary information is a JSON object containing a map from container name to list of summary objects. Summary object is the marshalled JSON of the `DerivedStats` struct found in [info/v2/container.go](../info/v2/container.go) ## Container Spec The resource name for container stats information is: `/api/v2.0/spec/` Additionally, `type` and `recursive` options can be used to describe the identifier type and ask for spec of all subcontainers respectively. The semantics are same as described for container stats above. The spec information is returned as a JSON object containing a map from container name to list of spec objects. Spec object is the marshalled JSON of the `ContainerSpec` struct found in [info/v2/container.go](../info/v2/container.go) cadvisor-0.25.0/docs/application_metrics.md000066400000000000000000000117501306035727200207240ustar00rootroot00000000000000# Collecting Application Metrics with cAdvisor **Note** Application metrics support is in Alpha. We are still making a bunch of interface changes. ## Introduction In addition to usage metrics, cAdvisor can also be configured to collect application metrics. A container can expose application metrics through multiple ways - on a status page, through structured info like prometheus, or have a separate API for fetching stats. cAdvisor provides a generic way to collect these metrics. Additional templates are provided to automate some well-known collection profiles. ## Specifying application metrics Application metrics specification consists of two steps: * Creating a configuration * Passing the configuration location to cadvisor ## Creating a configuration An application metric configuration tells cAdvisor where to look for application metrics and specifies other parameters about how to export the metrics from cAdvisor to UI and backends. The metric config includes: * Endpoint (Location to collect metrics from) * Name of metric * Type (Counter, Gauge, ...) * Data Type (int, float) * Units (kbps, seconds, count) * Polling Frequency * Regexps (Regular expressions to specify which metrics to collect and how to parse them) Here is an example of a very generic metric collector that assumes no structured information: ``` { "endpoint" : "http://localhost:8000/nginx_status", "metrics_config" : [ { "name" : "activeConnections", "metric_type" : "gauge", "units" : "number of active connections", "data_type" : "int", "polling_frequency" : 10, "regex" : "Active connections: ([0-9]+)" }, { "name" : "reading", "metric_type" : "gauge", "units" : "number of reading connections", "data_type" : "int", "polling_frequency" : 10, "regex" : "Reading: ([0-9]+) .*" } ] } ``` For structured metrics export, eg. Prometheus, the config can shrink down to just the endpoint, as other information can be gleaned from the structure. Here is a sample prometheus config that collects all metrics from an endpoint. ``` { "endpoint" : "http://localhost:9100/metrics" } ``` Another sample config that collects only selected metrics: ``` { "endpoint" : "http://localhost:8000/metrics", "metrics_config" : [ "scheduler_binding_latency", "scheduler_e2e_scheduling_latency", "scheduling_algorithm_latency" ] } ``` ## Passing the configuration to cAdvisor cAdvisor can discover any configurations for a container using Docker container labels. Any label starting with ```io.cadvisor.metric``` is parsed as a cadvisor application-metric label. cAdvisor uses the value as an indicator of where the configuration can be found. Labels of the form ```io.cadvisor.metric.prometheus-xyz``` indicate that the configuration points to a Prometheus metrics endpoint. The configuration file can either be part of the container image or can be added on at runtime with a volume. This makes sure that there is no connection between the host where the container is running and the application metrics configuration. A container is self-contained for its metric information. So a sample configuration for redis would look like: Dockerfile (or runtime): ``` FROM redis ADD redis_config.json /var/cadvisor/redis_config.json LABEL io.cadvisor.metric.redis="/var/cadvisor/redis_config.json" ``` cAdvisor will then reach into the container image at runtime, process the config, and start collecting and exposing application metrics. Note that cAdvisor specifically looks at the container labels to extract this information. In Docker 1.8, containers don't inherit labels from their images, and thus you must specify the label at runtime. ## API access to application-specific metrics A new endpoint is added for collecting application-specific metrics for a particular container: ``` http://localhost:8080/api/v2.0/appmetrics/containerName ``` The set of application-metrics being collected can be discovered from the container spec: ``` http://localhost:8080/api/v2.0/spec/containerName ``` Regular stats API also has application-metrics appended to it: ``` http://localhost:8080/api/v2.0/stats/containerName ``` ## UI changes Application-metrics show up on the container page after the resource metrics. ## Ongoing work ### Templates Next step for application-metrics is to add templates for well-known containers that have stable stats API. These would be specified by a new label ```io.cadvisor.metric.type```. If the label value is a known type, cAdvisor would start collecting stats automatically without needing any further config. Config can still be used to override any specific parameters - like set of metrics to collect. ### UI enhancements There are a bunch of UI enhancements under way: * Better handling/display of metrics - eg. allowing overlaying metrics on the same graphs, handling metric types like percentiles. * Moving application metrics to separate tab. * Adding control to show only selected metrics on UI while still exporting everything through the API. cadvisor-0.25.0/docs/clients.md000066400000000000000000000007031306035727200163300ustar00rootroot00000000000000# cAdvisor API Clients There is an official Go client implementation in the [client](../client/) directory. You can use it on your own Go project by including it like this: ```go import "github.com/google/cadvisor/client" client, err = client.NewClient("http://localhost:8080/") mInfo, err := client.MachineInfo() ``` Do you know of another cAdvisor client? Maybe in another language? Please let us know! We'd be happy to add a note on this page. cadvisor-0.25.0/docs/deploy.md000066400000000000000000000013241306035727200161630ustar00rootroot00000000000000# Building and Deploying the cAdvisor Docker Container ## Building Building the cAdvisor Docker container is simple, just run: ``` $ ./deploy/build.sh ``` Which will statically build the cAdvisor binary and then build the Docker image. The resulting Docker image will be called `google/cadvisor:canary`. This image is very bare, containing the cAdvisor binary and nothing else. ## Deploying All cAdvisor releases are tagged and correspond to a Docker image. The latest supported release uses the `latest` tag. We have a `beta` and `canary` tag for pre-release versions with newer features. You can see more details about this in the cAdvisor Docker [registry](https://registry.hub.docker.com/u/google/cadvisor/) page. cadvisor-0.25.0/docs/development/000077500000000000000000000000001306035727200166675ustar00rootroot00000000000000cadvisor-0.25.0/docs/development/README.md000066400000000000000000000003531306035727200201470ustar00rootroot00000000000000The [development](./) directory holds documentation for cAdvisor developers and contributors. If you are looking for development using cAdvisor (as opposed to development of cAdvisor), then these documents probably don't apply to you. cadvisor-0.25.0/docs/development/build.md000066400000000000000000000022141306035727200203070ustar00rootroot00000000000000# Building and Testing cAdvisor **Note**: cAdvisor only builds on Linux since it uses Linux-only APIs. ## Installing Dependencies cAdvisor is written in the [Go](http://golang.org) programming language. If you haven't set up a Go development environment, please follow [these instructions](http://golang.org/doc/code.html) to install go tool and set up GOPATH. Note that the version of Go in package repositories of some operating systems is outdated, so please [download](https://golang.org/dl/) the latest version. **Note**: cAdvisor requires Go 1.6 to build. After setting up Go, you should be able to `go get` cAdvisor as expected (we use `-d` to only download): ``` $ go get -d github.com/google/cadvisor ``` ## Building from Source At this point you can build cAdvisor from the source folder: ``` $GOPATH/src/github.com/google/cadvisor $ make build ``` or run only unit tests: ``` $GOPATH/src/github.com/google/cadvisor $ make test ``` For integration tests, see the [integration testing](integration_testing.md) page. ## Running Built Binary Now you can run the built binary: ``` $GOPATH/src/github.com/google/cadvisor $ sudo ./cadvisor ``` cadvisor-0.25.0/docs/development/integration_testing.md000066400000000000000000000012601306035727200232700ustar00rootroot00000000000000# Integration Testing cAdvisor The cAdvisor integration tests can be found in `integration/tests`. These run queries on a running cAdvisor. To run these tests: ``` $ go run integration/runner/runner.go -port=PORT ``` This will build a cAdvisor from the current repository and start it on the target machine before running the tests. To simply run the tests against an existing cAdvisor: ``` $ go test github.com/google/cadvisor/integration/tests/... -host=HOST -port=PORT ``` Note that `HOST` and `PORT` default to `localhost` and `8080` respectively. Today We only support remote execution in Google Compute Engine since that is where we run our continuous builds. cadvisor-0.25.0/docs/development/issues.md000066400000000000000000000040301306035727200205210ustar00rootroot00000000000000# GitHub Issue tracking cAdvisor This document outlines the process around GitHub issue tracking for cAdvisor at https://github.com/google/cadvisor/issues ## Labels A brief explanation of what issue labels mean. Most labels also apply to pull requests, but for pull requests which reference an issue, it is not necessary to copy the same labels to the PR. - `area/API` - For issues related to the API. - `area/UI` - For issues related to the web UI. - `area/documentation` - For issues related to the documentation (inline comments or markdown). - `area/performance` - For issues related to cAdvisor performance (speed, memory, etc.). - `area/storage` - For issues related to cAdvisor storage plugins. - `area/testing` - For issues related to testing (integration tests, unit tests, jenkins, etc.) - `closed/duplicate` - For issues which have been closed as duplicates of another issue. The final comment on the issue should hold a reference the duplicate issue. - `closed/infeasible` - For issues which cannot be resolved (e.g. a request for a feature we cannot or do not want to add). - `community-assigned` - For issues which are being worked on by a community member (when github won't let us assign the issue to them). - `kind/bug` - For issues referring to a bug in the existing implementation. - `kind/enhancement` - For issues proposing an enhancement or new feature. - `kind/support` - For issues which might just be user confusion / environment setup. If support issue ends up requiring a PR, it should probably be relabeled (for example, to `bug`). Many support issues may indicate a shortcoming of the documentation. - `help wanted` - For issues which have been highlighted as a good place to contribute to cAdvisor. `help wanted` issues could be enhancements that the core team is unlikely to get to in the near future, or small projects which might be a good starting point. Lack of a `help wanted` label does not mean we won't accept contributions, it only means it was not identified as a candidate project for community contributions. cadvisor-0.25.0/docs/development/releasing.md000066400000000000000000000061221306035727200211630ustar00rootroot00000000000000# cAdvisor Release Instructions Google internal-only version: [cAdvisor Release Instructions](http://go/cadvisor-release-instructions) ## 1. Send Release PR Example: https://github.com/google/cadvisor/pull/1281 Add release notes to [CHANGELOG.md](../../CHANGELOG.md) - Tip: Use a github PR search to find changes since the last release `is:pr is:merged merged:>2016-04-21` ## 2. Create the release tag ### 2.a Create the release branch (only for major/minor releases) Skip this step for patch releases. ``` # Sync to HEAD, or the commit to branch at $ git fetch upstream && git checkout upstream/master # Create the branch $ git branch release-v0.XX # Push it to upstream $ git push git@github.com:google/cadvisor.git release-v0.XX ``` ### 2.b Tag the release For a release of minor version XX, patch version YY: ``` # Checkout the release branch $ git fetch upstream && git checkout upstream/release-v0.XX # Tag the release commit. If you aren't signing, ommit the -s $ git tag -s -a v0.XX.YY # Push it to upstream $ git push git@github.com:google/cadvisor.git v0.XX.YY ``` ## 3. Build release binary Command: `make release` - Make sure your git client is synced to the release cut point - Try to build it from the release branch, since we include that in the binary version - Verify the ldflags output, in particular check the Version, BuildUser, and GoVersion are expected Once the build is complete, check the VERSION and note the sha256 hash. ## 4. Push the Docker images Docker Hub: ``` $ docker login Username: **** Password: **** $ docker push google/cadvisor:$VERSION $ docker logout # Good practice with shared account ``` Google Container Registry: ``` $ gcloud auth login ... Go to the following link in your browser: https://accounts.google.com/o/oauth2/auth? Enter verification code: **** $ gcloud docker push gcr.io/google_containers/cadvisor:$VERSION $ gcloud auth revoke # Log out of shared account ``` ## 5. Cut the release Go to https://github.com/google/cadvisor/releases and click "Draft a new release" - "Tag version" and "Release title" should be preceded by 'v' and then the version. Select the tag pushed in step 2.b - Copy an old release as a template (e.g. github.com/google/cadvisor/releases/tag/v0.23.1) - Body should start with release notes (from CHANGELOG.md) - Next is the Docker image: `google/cadvisor:$VERSION` - Next are the binary hashes (from step 3) - Upload the binary build in step 3 - If this is an alpha or beta release, mark the release as a "pre-release" - Click publish when done ## 6. Finalize the release Once you are satisfied with the release quality (consider waiting a week for bug reports to come in), it is time to promote the release to *latest* 1. Edit the github release a final time, and uncheck the "Pre-release" checkbox 2. Tag the docker & gcr.io releases with the latest version ``` $ docker pull google/cadvisor:$VERSION $ docker tag -f google/cadvisor:$VERSION google/cadvisor:latest $ docker tag -f google/cadvisor:$VERSION gcr.io/google_containers/cadvisor:latest ``` 3. Repeat steps 4.a and 4.b to push the image tagged with latest cadvisor-0.25.0/docs/running.md000066400000000000000000000065211306035727200163530ustar00rootroot00000000000000# Running cAdvisor ## With Docker We have a Docker image that includes everything you need to get started. Simply run: ``` sudo docker run \ --volume=/:/rootfs:ro \ --volume=/var/run:/var/run:rw \ --volume=/sys:/sys:ro \ --volume=/var/lib/docker/:/var/lib/docker:ro \ --publish=8080:8080 \ --detach=true \ --name=cadvisor \ google/cadvisor:latest ``` cAdvisor is now running (in the background) on `http://localhost:8080/`. The setup includes directories with Docker state cAdvisor needs to observe. ## Latest Canary The latest cAdvisor canary release is continuously built from HEAD and available as an Automated Build Docker image: [google/cadvisor-canary](https://registry.hub.docker.com/u/google/cadvisor-canary/). We do *not* recommend using this image in production due to its large size and volatility. ## With Boot2Docker After booting up a boot2docker instance, run cAdvisor image with the same docker command mentioned above. cAdvisor can now be accessed at port 8080 of your boot2docker instance. The host IP can be found through DOCKER_HOST environment variable setup by boot2docker: ``` $ echo $DOCKER_HOST tcp://192.168.59.103:2376 ``` In this case, cAdvisor UI should be accessible on `http://192.168.59.103:8080` ## Other Configurations ### CentOS, Fedora, and RHEL You may need to run the container with `--privileged=true` and `--volume=/cgroup:/cgroup:ro \` in order for cAdvisor to monitor Docker containers. RHEL and CentOS lock down their containers a bit more. cAdvisor needs access to the Docker daemon through its socket. This requires `--privileged=true` in RHEL and CentOS. On some versions of RHEL and CentOS the cgroup hierarchies are mounted in `/cgroup` so run cAdvisor with an additional Docker option of `--volume=/cgroup:/cgroup:ro \`. ### Debian By default, Debian disables the memory cgroup which does not allow cAdvisor to gather memory stats. To enable the memory cgroup take a look at [these instructions](https://github.com/google/cadvisor/issues/432). ### LXC Docker exec driver If you are using Docker with the LXC exec driver, then you need to manually specify all cgroup mounts by adding the: ``` --volume=/cgroup/cpu:/cgroup/cpu \ --volume=/cgroup/cpuacct:/cgroup/cpuacct \ --volume=/cgroup/cpuset:/cgroup/cpuset \ --volume=/cgroup/memory:/cgroup/memory \ --volume=/cgroup/blkio:/cgroup/blkio \ ``` ### Invalid Bindmount `/` This is a problem seen in older versions of Docker. To fix, start cAdvisor without the `--volume=/:/rootfs:ro` mount. cAdvisor will degrade gracefully by dropping stats that depend on access to the machine root. ## Standalone cAdvisor is a static Go binary with no external dependencies. To run it standalone all you should need to do is run it! Note that some data sources may require root priviledges. cAdvisor will gracefully degrade its features to those it can expose with the access given. ``` $ sudo cadvisor ``` cAdvisor is now running (in the foreground) on `http://localhost:8080/`. ## Runtime Options cAdvisor has a series of flags that can be used to configure its runtime behavior. More details can be found in runtime [options](runtime_options.md). ## I need help! We aim to have cAdvisor run everywhere! If you run into issues getting it running, feel free to file an issue. We are very responsive in supporting our users and update our documentation with new setups. cadvisor-0.25.0/docs/runtime_options.md000066400000000000000000000055661306035727200201410ustar00rootroot00000000000000# cAdvisor Runtime Options This document describes a set of runtime flags available in cAdvisor. ## Local Storage Duration cAdvisor stores the latest historical data in memory. How long of a history it stores can be configured with the `--storage_duration` flag. ``` --storage_duration: How long to store data. ``` ## Housekeeping Housekeeping is the periodic actions cAdvisor takes. During these actions, cAdvisor will gather container stats. These flags control how and when cAdvisor performs housekeeping. #### Dynamic Housekeeping Dynamic housekeeping intervals let cAdvisor vary how often it gathers stats. It does this depending on how active the container is. Turning this off provides predictable housekeeping intervals, but increases the resource usage of cAdvisor. ``` --allow_dynamic_housekeeping=true: Whether to allow the housekeeping interval to be dynamic ``` #### Housekeeping Intervals Intervals for housekeeping. cAdvisor has two housekeepings: global and per-container. Global housekeeping is a singular housekeeping done once in cAdvisor. This typically does detection of new containers. Today, cAdvisor discovers new containers with kernel events so this global housekeeping is mostly used as backup in the case that there are any missed events. Per-container housekeeping is run once on each container cAdvisor tracks. This typically gets container stats. ``` --global_housekeeping_interval=1m0s: Interval between global housekeepings --housekeeping_interval=1s: Interval between container housekeepings ``` ## Container Hints Container hints are a way to pass extra information about a container to cAdvisor. In this way cAdvisor can augment the stats it gathers. For more information on the container hints format see its [definition](../container/common/container_hints.go). Note that container hints are only used by the raw container driver today. ``` --container_hints="/etc/cadvisor/container_hints.json": location of the container hints file ``` ## HTTP Specify where cAdvisor listens. ``` --listen_ip="": IP to listen on, defaults to all IPs --port=8080: port to listen ``` ## Debugging and Logging cAdvisor-native flags that help in debugging: ``` --log_cadvisor_usage=false: Whether to log the usage of the cAdvisor container --version=false: print cAdvisor version and exit --profiling=false: Enable profiling via web interface host:port/debug/pprof/ ``` From [glog](https://github.com/golang/glog) here are some flags we find useful: ``` --log_dir="": If non-empty, write log files in this directory --logtostderr=false: log to standard error instead of files --alsologtostderr=false: log to standard error as well as files --stderrthreshold=0: logs at or above this threshold go to stderr --v=0: log level for V logs --vmodule=: comma-separated list of pattern=N settings for file-filtered logging ``` ## Storage Drivers See [InfluxDB instructions](storage/influxdb.md). cadvisor-0.25.0/docs/storage/000077500000000000000000000000001306035727200160115ustar00rootroot00000000000000cadvisor-0.25.0/docs/storage/README.md000066400000000000000000000014451306035727200172740ustar00rootroot00000000000000# cAdvisor Storage Plugins cAdvisor supports exporting stats to various storage driver plugins. To enable a storage driver, set the `-storage_driver` flag. ## Storage drivers - [BigQuery](https://cloud.google.com/bigquery/). See the [documentation](../../storage/bigquery/README.md) for usage. - [ElasticSearch](https://www.elastic.co/). See the [documentation](elasticsearch.md) for usage and examples. - [InfluxDB](https://influxdb.com/). See the [documentation](influxdb.md) for usage and examples. - [Kafka](http://kafka.apache.org/). See the [documentation](kafka.md) for usage. - [Prometheus](https://prometheus.io). See the [documentation](prometheus.md) for usage and examples. - [Redis](http://redis.io/) - [StatsD](https://github.com/etsy/statsd) - `stdout` - write stats to standard output. cadvisor-0.25.0/docs/storage/elasticsearch.md000066400000000000000000000013711306035727200211470ustar00rootroot00000000000000# Exporting cAdvisor Stats to ElasticSearch cAdvisor supports exporting stats to [ElasticSearch](https://www.elastic.co/). To use ES, you need to provide the additional flags to cAdvisor: Set the storage driver as ES: ``` -storage_driver=elasticsearch ``` Specify ES host address: ``` -storage_driver_es_host="http://elasticsearch:9200" ``` There are also optional flags: ``` # ElasticSearch type name. By default it's "stats". -storage_driver_es_type="stats" # ElasticSearch can use a sniffing process to find all nodes of your cluster automatically. False by default. -storage_driver_es_enable_sniffer=false ``` # Examples For a detailed tutorial, see [docker-elk-cadvisor-dashboards](https://github.com/gregbkr/docker-elk-cadvisor-dashboards) cadvisor-0.25.0/docs/storage/influxdb.md000066400000000000000000000021241306035727200201450ustar00rootroot00000000000000# Exporting cAdvisor Stats to InfluxDB cAdvisor supports exporting stats to [InfluxDB](http://influxdb.com). To use InfluxDB, you need to pass some additional flags to cAdvisor telling it where the InfluxDB instance is located: Set the storage driver as InfluxDB. ``` -storage_driver=influxdb ``` Specify what InfluxDB instance to push data to: ``` # The *ip:port* of the database. Default is 'localhost:8086' -storage_driver_host=ip:port # database name. Uses db 'cadvisor' by default -storage_driver_db # database username. Default is 'root' -storage_driver_user # database password. Default is 'root' -storage_driver_password # Use secure connection with database. False by default -storage_driver_secure ``` # Examples [Brian Christner](https://www.brianchristner.io) wrote a detailed post on [setting up Docker monitoring](https://www.brianchristner.io/how-to-setup-docker-monitoring) with cAdvisor and Influxdb. A docker compose configuration for setting up cadvisor-influxdb-grafana can be found [here](https://github.com/dalekurt/docker-monitoring/blob/master/docker-compose.yml). cadvisor-0.25.0/docs/storage/kafka.md000066400000000000000000000020241306035727200174060ustar00rootroot00000000000000# Exporting cAdvisor Stats to Kafka cAdvisor supports exporting stats to [Kafka](http://kafka.apache.org/). To use Kafka, you need to provide the additional flags to cAdvisor: Set the storage driver as Kafka: ``` -storage_driver=kafka ``` If no broker are provided it will default to a broker listening at localhost:9092, with 'stats' as the default topic. Specify a Kafka broker address: ``` -storage_driver_kafka_broker_list=localhost:9092 ``` Specify a Kafka topic: ``` -storage_driver_kafka_topic=myTopic ``` As of version 9.0. Kafka supports TLS client auth: ``` # To enable TLS client auth support you need to provide the following: # Location to Certificate Authority certificate -storage_driver_kafka_ssl_ca=/path/to/ca.pem # Location to client certificate certificate -storage_driver_kafka_ssl_cert=/path/to/client_cert.pem # Location to client certificate key -storage_driver_kafka_ssl_key=/path/to/client_key.pem # Verify SSL certificate chain (default: true) -storage_driver_kafka_ssl_verify=false ``` cadvisor-0.25.0/docs/storage/prometheus.md000066400000000000000000000024121306035727200205250ustar00rootroot00000000000000# Monitoring cAdvisor with Prometheus cAdvisor exposes container statistics as [Prometheus](https://prometheus.io) metrics out of the box. By default, these metrics are served under the `/metrics` HTTP endpoint. This endpoint may be customized by setting the `-prometheus_endpoint` command-line flag. To monitor cAdvisor with Prometheus, simply configure one or more jobs in Prometheus which scrape the relevant cAdvisor processes at that metrics endpoint. For details, see Prometheus's [Configuration](https://prometheus.io/docs/operating/configuration/) documentation, as well as the [Getting started](https://prometheus.io/docs/introduction/getting_started/) guide. # Examples * [CenturyLink Labs](https://labs.ctl.io/) did an excellent write up on [Monitoring Docker services with Prometheus +cAdvisor](https://labs.ctl.io/monitoring-docker-services-with-prometheus/), while it is great to get a better overview of cAdvisor integration with Prometheus, the PromDash GUI part is outdated as it has been deprecated for Grafana. * [vegasbrianc](https://github.com/vegasbrianc) provides a [starter project](https://github.com/vegasbrianc/prometheus) for cAdvisor and Prometheus monitoring, alongide a ready-to-use [Grafana dashboard](https://github.com/vegasbrianc/grafana_dashboard). cadvisor-0.25.0/docs/web.md000066400000000000000000000024461306035727200154520ustar00rootroot00000000000000# cAdvisor Web UI cAdvisor exposes a web UI at its port: `http://:/` This UI has one primary resource at `/containers` which exports live information about all containers on the machine. ## Web UI authentication You can add authentication to the web UI by either HTTP basic or HTTP digest authentication. ### HTTP basic authentication You will need to add a *http_auth_file* parameter with a HTTP basic auth file generated using htpasswd to enable HTTP basic auth. By default the auth realm is set as localhost. `./cadvisor --http_auth_file test.htpasswd --http_auth_realm localhost` The [test.htpasswd](../test.htpasswd) file provided has a username and password already added (admin:password1) for testing purposes. ### HTTP Digest authentication You will need to add a *http_digest_file* parameter with a HTTP digest auth file generated using htdigest to enable HTTP Digest auth. By default the auth realm is set as localhost. `./cadvisor --http_digest_file test.htdigest --http_digest_realm localhost` The [test.htdigest](../test.htdigest) file provided has a username and password already added (admin:password1) for testing purposes. **Note** : You can use either type of authentication, in case you decide to use both files in the arguments only HTTP basic auth will be enabled. cadvisor-0.25.0/events/000077500000000000000000000000001306035727200147215ustar00rootroot00000000000000cadvisor-0.25.0/events/handler.go000066400000000000000000000257231306035727200166760ustar00rootroot00000000000000// Copyright 2015 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 events import ( "errors" "sort" "strings" "sync" "time" info "github.com/google/cadvisor/info/v1" "github.com/google/cadvisor/utils" "github.com/golang/glog" ) type byTimestamp []*info.Event // functions necessary to implement the sort interface on the Events struct func (e byTimestamp) Len() int { return len(e) } func (e byTimestamp) Swap(i, j int) { e[i], e[j] = e[j], e[i] } func (e byTimestamp) Less(i, j int) bool { return e[i].Timestamp.Before(e[j].Timestamp) } type EventChannel struct { // Watch ID. Can be used by the caller to request cancellation of watch events. watchId int // Channel on which the caller can receive watch events. channel chan *info.Event } // Request holds a set of parameters by which Event objects may be screened. // The caller may want events that occurred within a specific timeframe // or of a certain type, which may be specified in the *Request object // they pass to an EventManager function type Request struct { // events falling before StartTime do not satisfy the request. StartTime // must be left blank in calls to WatchEvents StartTime time.Time // events falling after EndTime do not satisfy the request. EndTime // must be left blank in calls to WatchEvents EndTime time.Time // EventType is a map that specifies the type(s) of events wanted EventType map[info.EventType]bool // allows the caller to put a limit on how many // events to receive. If there are more events than MaxEventsReturned // then the most chronologically recent events in the time period // specified are returned. Must be >= 1 MaxEventsReturned int // the absolute container name for which the event occurred ContainerName string // if IncludeSubcontainers is false, only events occurring in the specific // container, and not the subcontainers, will be returned IncludeSubcontainers bool } // EventManager is implemented by Events. It provides two ways to monitor // events and one way to add events type EventManager interface { // WatchEvents() allows a caller to register for receiving events based on the specified request. // On successful registration, an EventChannel object is returned. WatchEvents(request *Request) (*EventChannel, error) // GetEvents() returns all detected events based on the filters specified in request. GetEvents(request *Request) ([]*info.Event, error) // AddEvent allows the caller to add an event to an EventManager // object AddEvent(e *info.Event) error // Cancels a previously requested watch event. StopWatch(watch_id int) } // events provides an implementation for the EventManager interface. type events struct { // eventStore holds the events by event type. eventStore map[info.EventType]*utils.TimedStore // map of registered watchers keyed by watch id. watchers map[int]*watch // lock guarding the eventStore. eventsLock sync.RWMutex // lock guarding watchers. watcherLock sync.RWMutex // last allocated watch id. lastId int // Event storage policy. storagePolicy StoragePolicy } // initialized by a call to WatchEvents(), a watch struct will then be added // to the events slice of *watch objects. When AddEvent() finds an event that // satisfies the request parameter of a watch object in events.watchers, // it will send that event out over the watch object's channel. The caller that // called WatchEvents will receive the event over the channel provided to // WatchEvents type watch struct { // request parameters passed in by the caller of WatchEvents() request *Request // a channel used to send event back to the caller. eventChannel *EventChannel } func NewEventChannel(watchId int) *EventChannel { return &EventChannel{ watchId: watchId, channel: make(chan *info.Event, 10), } } // Policy specifying how many events to store. // MaxAge is the max duration for which to keep events. // MaxNumEvents is the max number of events to keep (-1 for no limit). type StoragePolicy struct { // Defaults limites, used if a per-event limit is not set. DefaultMaxAge time.Duration DefaultMaxNumEvents int // Per-event type limits. PerTypeMaxAge map[info.EventType]time.Duration PerTypeMaxNumEvents map[info.EventType]int } func DefaultStoragePolicy() StoragePolicy { return StoragePolicy{ DefaultMaxAge: 24 * time.Hour, DefaultMaxNumEvents: 100000, PerTypeMaxAge: make(map[info.EventType]time.Duration), PerTypeMaxNumEvents: make(map[info.EventType]int), } } // returns a pointer to an initialized Events object. func NewEventManager(storagePolicy StoragePolicy) *events { return &events{ eventStore: make(map[info.EventType]*utils.TimedStore, 0), watchers: make(map[int]*watch), storagePolicy: storagePolicy, } } // returns a pointer to an initialized Request object func NewRequest() *Request { return &Request{ EventType: map[info.EventType]bool{}, IncludeSubcontainers: false, MaxEventsReturned: 10, } } // returns a pointer to an initialized watch object func newWatch(request *Request, eventChannel *EventChannel) *watch { return &watch{ request: request, eventChannel: eventChannel, } } func (self *EventChannel) GetChannel() chan *info.Event { return self.channel } func (self *EventChannel) GetWatchId() int { return self.watchId } // sorts and returns up to the last MaxEventsReturned chronological elements func getMaxEventsReturned(request *Request, eSlice []*info.Event) []*info.Event { sort.Sort(byTimestamp(eSlice)) n := request.MaxEventsReturned if n >= len(eSlice) || n <= 0 { return eSlice } return eSlice[len(eSlice)-n:] } // If the request wants all subcontainers, this returns if the request's // container path is a prefix of the event container path. Otherwise, // it checks that the container paths of the event and request are // equivalent func checkIfIsSubcontainer(request *Request, event *info.Event) bool { if request.IncludeSubcontainers == true { return request.ContainerName == "/" || strings.HasPrefix(event.ContainerName+"/", request.ContainerName+"/") } return event.ContainerName == request.ContainerName } // determines if an event occurs within the time set in the request object and is the right type func checkIfEventSatisfiesRequest(request *Request, event *info.Event) bool { startTime := request.StartTime endTime := request.EndTime eventTime := event.Timestamp if !startTime.IsZero() { if startTime.After(eventTime) { return false } } if !endTime.IsZero() { if endTime.Before(eventTime) { return false } } if !request.EventType[event.EventType] { return false } if request.ContainerName != "" { return checkIfIsSubcontainer(request, event) } return true } // method of Events object that screens Event objects found in the eventStore // attribute and if they fit the parameters passed by the Request object, // adds it to a slice of *Event objects that is returned. If both MaxEventsReturned // and StartTime/EndTime are specified in the request object, then only // up to the most recent MaxEventsReturned events in that time range are returned. func (self *events) GetEvents(request *Request) ([]*info.Event, error) { returnEventList := []*info.Event{} self.eventsLock.RLock() defer self.eventsLock.RUnlock() for eventType, fetch := range request.EventType { if !fetch { continue } evs, ok := self.eventStore[eventType] if !ok { continue } res := evs.InTimeRange(request.StartTime, request.EndTime, request.MaxEventsReturned) for _, in := range res { e := in.(*info.Event) if checkIfEventSatisfiesRequest(request, e) { returnEventList = append(returnEventList, e) } } } returnEventList = getMaxEventsReturned(request, returnEventList) return returnEventList, nil } // method of Events object that maintains an *Event channel passed by the user. // When an event is added by AddEvents that satisfies the parameters in the passed // Request object it is fed to the channel. The StartTime and EndTime of the watch // request should be uninitialized because the purpose is to watch indefinitely // for events that will happen in the future func (self *events) WatchEvents(request *Request) (*EventChannel, error) { if !request.StartTime.IsZero() || !request.EndTime.IsZero() { return nil, errors.New( "for a call to watch, request.StartTime and request.EndTime must be uninitialized") } self.watcherLock.Lock() defer self.watcherLock.Unlock() new_id := self.lastId + 1 returnEventChannel := NewEventChannel(new_id) newWatcher := newWatch(request, returnEventChannel) self.watchers[new_id] = newWatcher self.lastId = new_id return returnEventChannel, nil } // helper function to update the event manager's eventStore func (self *events) updateEventStore(e *info.Event) { self.eventsLock.Lock() defer self.eventsLock.Unlock() if _, ok := self.eventStore[e.EventType]; !ok { maxNumEvents := self.storagePolicy.DefaultMaxNumEvents if numEvents, ok := self.storagePolicy.PerTypeMaxNumEvents[e.EventType]; ok { maxNumEvents = numEvents } if maxNumEvents == 0 { // Event storage is disabled for e.EventType return } maxAge := self.storagePolicy.DefaultMaxAge if age, ok := self.storagePolicy.PerTypeMaxAge[e.EventType]; ok { maxAge = age } self.eventStore[e.EventType] = utils.NewTimedStore(maxAge, maxNumEvents) } self.eventStore[e.EventType].Add(e.Timestamp, e) } func (self *events) findValidWatchers(e *info.Event) []*watch { watchesToSend := make([]*watch, 0) for _, watcher := range self.watchers { watchRequest := watcher.request if checkIfEventSatisfiesRequest(watchRequest, e) { watchesToSend = append(watchesToSend, watcher) } } return watchesToSend } // method of Events object that adds the argument Event object to the // eventStore. It also feeds the event to a set of watch channels // held by the manager if it satisfies the request keys of the channels func (self *events) AddEvent(e *info.Event) error { self.updateEventStore(e) self.watcherLock.RLock() defer self.watcherLock.RUnlock() watchesToSend := self.findValidWatchers(e) for _, watchObject := range watchesToSend { watchObject.eventChannel.GetChannel() <- e } glog.V(4).Infof("Added event %v", e) return nil } // Removes a watch instance from the EventManager's watchers map func (self *events) StopWatch(watchId int) { self.watcherLock.Lock() defer self.watcherLock.Unlock() _, ok := self.watchers[watchId] if !ok { glog.Errorf("Could not find watcher instance %v", watchId) } close(self.watchers[watchId].eventChannel.GetChannel()) delete(self.watchers, watchId) } cadvisor-0.25.0/events/handler_test.go000066400000000000000000000142151306035727200177270ustar00rootroot00000000000000// Copyright 2015 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 events import ( "testing" "time" info "github.com/google/cadvisor/info/v1" "github.com/stretchr/testify/assert" ) func createOldTime(t *testing.T) time.Time { const longForm = "Jan 2, 2006 at 3:04pm (MST)" linetime, err := time.Parse(longForm, "Feb 3, 2013 at 7:54pm (PST)") if err != nil { t.Fatalf("could not format time.Time object") } else { return linetime } return time.Now() } // used to convert an OomInstance to an Event object func makeEvent(inTime time.Time, containerName string) *info.Event { return &info.Event{ ContainerName: containerName, Timestamp: inTime, EventType: info.EventOom, } } // returns EventManager and Request to use in tests func initializeScenario(t *testing.T) (*events, *Request, *info.Event, *info.Event) { fakeEvent := makeEvent(createOldTime(t), "/") fakeEvent2 := makeEvent(time.Now(), "/") return NewEventManager(DefaultStoragePolicy()), NewRequest(), fakeEvent, fakeEvent2 } func checkNumberOfEvents(t *testing.T, numEventsExpected int, numEventsReceived int) { if numEventsReceived != numEventsExpected { t.Fatalf("Expected to return %v events but received %v", numEventsExpected, numEventsReceived) } } func ensureProperEventReturned(t *testing.T, expectedEvent *info.Event, eventObjectFound *info.Event) { if eventObjectFound != expectedEvent { t.Errorf("Expected to find test object %v but found a different object: %v", expectedEvent, eventObjectFound) } } func TestCheckIfIsSubcontainer(t *testing.T) { myRequest := NewRequest() myRequest.ContainerName = "/root" rootRequest := NewRequest() rootRequest.ContainerName = "/" sameContainerEvent := &info.Event{ ContainerName: "/root", } subContainerEvent := &info.Event{ ContainerName: "/root/subdir", } differentContainerEvent := &info.Event{ ContainerName: "/root-completely-different-container", } if checkIfIsSubcontainer(rootRequest, sameContainerEvent) { t.Errorf("should not have found %v to be a subcontainer of %v", sameContainerEvent, rootRequest) } if !checkIfIsSubcontainer(myRequest, sameContainerEvent) { t.Errorf("should have found %v and %v had the same container name", myRequest, sameContainerEvent) } if checkIfIsSubcontainer(myRequest, subContainerEvent) { t.Errorf("should have found %v and %v had different containers", myRequest, subContainerEvent) } rootRequest.IncludeSubcontainers = true myRequest.IncludeSubcontainers = true if !checkIfIsSubcontainer(rootRequest, sameContainerEvent) { t.Errorf("should have found %v to be a subcontainer of %v", sameContainerEvent.ContainerName, rootRequest.ContainerName) } if !checkIfIsSubcontainer(myRequest, sameContainerEvent) { t.Errorf("should have found %v and %v had the same container", myRequest.ContainerName, sameContainerEvent.ContainerName) } if !checkIfIsSubcontainer(myRequest, subContainerEvent) { t.Errorf("should have found %v was a subcontainer of %v", subContainerEvent.ContainerName, myRequest.ContainerName) } if checkIfIsSubcontainer(myRequest, differentContainerEvent) { t.Errorf("should have found %v and %v had different containers", myRequest.ContainerName, differentContainerEvent.ContainerName) } } func TestWatchEventsDetectsNewEvents(t *testing.T) { myEventHolder, myRequest, fakeEvent, fakeEvent2 := initializeScenario(t) myRequest.EventType[info.EventOom] = true returnEventChannel, err := myEventHolder.WatchEvents(myRequest) assert.Nil(t, err) myEventHolder.AddEvent(fakeEvent) myEventHolder.AddEvent(fakeEvent2) startTime := time.Now() go func() { time.Sleep(5 * time.Second) if time.Since(startTime) > (5 * time.Second) { t.Errorf("Took too long to receive all the events") } }() eventsFound := 0 go func() { for event := range returnEventChannel.GetChannel() { eventsFound += 1 if eventsFound == 1 { ensureProperEventReturned(t, fakeEvent, event) } else if eventsFound == 2 { ensureProperEventReturned(t, fakeEvent2, event) break } } }() } func TestAddEventAddsEventsToEventManager(t *testing.T) { myEventHolder, _, fakeEvent, _ := initializeScenario(t) myEventHolder.AddEvent(fakeEvent) checkNumberOfEvents(t, 1, len(myEventHolder.eventStore)) ensureProperEventReturned(t, fakeEvent, myEventHolder.eventStore[info.EventOom].Get(0).(*info.Event)) } func TestGetEventsForOneEvent(t *testing.T) { myEventHolder, myRequest, fakeEvent, fakeEvent2 := initializeScenario(t) myRequest.MaxEventsReturned = 1 myRequest.EventType[info.EventOom] = true myEventHolder.AddEvent(fakeEvent) myEventHolder.AddEvent(fakeEvent2) receivedEvents, err := myEventHolder.GetEvents(myRequest) assert.Nil(t, err) checkNumberOfEvents(t, 1, len(receivedEvents)) ensureProperEventReturned(t, fakeEvent2, receivedEvents[0]) } func TestGetEventsForTimePeriod(t *testing.T) { myEventHolder, myRequest, fakeEvent, fakeEvent2 := initializeScenario(t) myRequest.StartTime = time.Now().Add(-1 * time.Second * 10) myRequest.EndTime = time.Now().Add(time.Second * 10) myRequest.EventType[info.EventOom] = true myEventHolder.AddEvent(fakeEvent) myEventHolder.AddEvent(fakeEvent2) receivedEvents, err := myEventHolder.GetEvents(myRequest) assert.Nil(t, err) checkNumberOfEvents(t, 1, len(receivedEvents)) ensureProperEventReturned(t, fakeEvent2, receivedEvents[0]) } func TestGetEventsForNoTypeRequested(t *testing.T) { myEventHolder, myRequest, fakeEvent, fakeEvent2 := initializeScenario(t) myEventHolder.AddEvent(fakeEvent) myEventHolder.AddEvent(fakeEvent2) receivedEvents, err := myEventHolder.GetEvents(myRequest) assert.Nil(t, err) checkNumberOfEvents(t, 0, len(receivedEvents)) } cadvisor-0.25.0/fs/000077500000000000000000000000001306035727200140255ustar00rootroot00000000000000cadvisor-0.25.0/fs/fs.go000066400000000000000000000424651306035727200147770ustar00rootroot00000000000000// Copyright 2014 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // +build linux // Provides Filesystem Stats package fs import ( "bufio" "bytes" "fmt" "io/ioutil" "os" "os/exec" "path" "path/filepath" "regexp" "strconv" "strings" "syscall" "time" "github.com/docker/docker/pkg/mount" "github.com/golang/glog" "github.com/google/cadvisor/devicemapper" dockerutil "github.com/google/cadvisor/utils/docker" zfs "github.com/mistifyio/go-zfs" ) const ( LabelSystemRoot = "root" LabelDockerImages = "docker-images" LabelRktImages = "rkt-images" ) // The maximum number of `du` and `find` tasks that can be running at once. const maxConcurrentOps = 20 // A pool for restricting the number of consecutive `du` and `find` tasks running. var pool = make(chan struct{}, maxConcurrentOps) func init() { for i := 0; i < maxConcurrentOps; i++ { releaseToken() } } func claimToken() { <-pool } func releaseToken() { pool <- struct{}{} } type partition struct { mountpoint string major uint minor uint fsType string blockSize uint } type RealFsInfo struct { // Map from block device path to partition information. partitions map[string]partition // Map from label to block device path. // Labels are intent-specific tags that are auto-detected. labels map[string]string // devicemapper client dmsetup devicemapper.DmsetupClient } type Context struct { // docker root directory. Docker DockerContext RktPath string } type DockerContext struct { Root string Driver string DriverStatus map[string]string } func NewFsInfo(context Context) (FsInfo, error) { mounts, err := mount.GetMounts() if err != nil { return nil, err } // Avoid devicemapper container mounts - these are tracked by the ThinPoolWatcher excluded := []string{fmt.Sprintf("%s/devicemapper/mnt", context.Docker.Root)} fsInfo := &RealFsInfo{ partitions: processMounts(mounts, excluded), labels: make(map[string]string, 0), dmsetup: devicemapper.NewDmsetupClient(), } fsInfo.addRktImagesLabel(context, mounts) // need to call this before the log line below printing out the partitions, as this function may // add a "partition" for devicemapper to fsInfo.partitions fsInfo.addDockerImagesLabel(context, mounts) glog.Infof("Filesystem partitions: %+v", fsInfo.partitions) fsInfo.addSystemRootLabel(mounts) return fsInfo, nil } func processMounts(mounts []*mount.Info, excludedMountpointPrefixes []string) map[string]partition { partitions := make(map[string]partition, 0) supportedFsType := map[string]bool{ // all ext systems are checked through prefix. "btrfs": true, "xfs": true, "zfs": true, } for _, mount := range mounts { if !strings.HasPrefix(mount.Fstype, "ext") && !supportedFsType[mount.Fstype] { continue } // Avoid bind mounts. if _, ok := partitions[mount.Source]; ok { continue } hasPrefix := false for _, prefix := range excludedMountpointPrefixes { if strings.HasPrefix(mount.Mountpoint, prefix) { hasPrefix = true break } } if hasPrefix { continue } partitions[mount.Source] = partition{ fsType: mount.Fstype, mountpoint: mount.Mountpoint, major: uint(mount.Major), minor: uint(mount.Minor), } } return partitions } // getDockerDeviceMapperInfo returns information about the devicemapper device and "partition" if // docker is using devicemapper for its storage driver. If a loopback device is being used, don't // return any information or error, as we want to report based on the actual partition where the // loopback file resides, inside of the loopback file itself. func (self *RealFsInfo) getDockerDeviceMapperInfo(context DockerContext) (string, *partition, error) { if context.Driver != DeviceMapper.String() { return "", nil, nil } dataLoopFile := context.DriverStatus[dockerutil.DriverStatusDataLoopFile] if len(dataLoopFile) > 0 { return "", nil, nil } dev, major, minor, blockSize, err := dockerDMDevice(context.DriverStatus, self.dmsetup) if err != nil { return "", nil, err } return dev, &partition{ fsType: DeviceMapper.String(), major: major, minor: minor, blockSize: blockSize, }, nil } // addSystemRootLabel attempts to determine which device contains the mount for /. func (self *RealFsInfo) addSystemRootLabel(mounts []*mount.Info) { for _, m := range mounts { if m.Mountpoint == "/" { self.partitions[m.Source] = partition{ fsType: m.Fstype, mountpoint: m.Mountpoint, major: uint(m.Major), minor: uint(m.Minor), } self.labels[LabelSystemRoot] = m.Source return } } } // addDockerImagesLabel attempts to determine which device contains the mount for docker images. func (self *RealFsInfo) addDockerImagesLabel(context Context, mounts []*mount.Info) { dockerDev, dockerPartition, err := self.getDockerDeviceMapperInfo(context.Docker) if err != nil { glog.Warningf("Could not get Docker devicemapper device: %v", err) } if len(dockerDev) > 0 && dockerPartition != nil { self.partitions[dockerDev] = *dockerPartition self.labels[LabelDockerImages] = dockerDev } else { self.updateContainerImagesPath(LabelDockerImages, mounts, getDockerImagePaths(context)) } } func (self *RealFsInfo) addRktImagesLabel(context Context, mounts []*mount.Info) { if context.RktPath != "" { rktPath := context.RktPath rktImagesPaths := map[string]struct{}{ "/": {}, } for rktPath != "/" && rktPath != "." { rktImagesPaths[rktPath] = struct{}{} rktPath = filepath.Dir(rktPath) } self.updateContainerImagesPath(LabelRktImages, mounts, rktImagesPaths) } } // Generate a list of possible mount points for docker image management from the docker root directory. // Right now, we look for each type of supported graph driver directories, but we can do better by parsing // some of the context from `docker info`. func getDockerImagePaths(context Context) map[string]struct{} { dockerImagePaths := map[string]struct{}{ "/": {}, } // TODO(rjnagal): Detect docker root and graphdriver directories from docker info. dockerRoot := context.Docker.Root for _, dir := range []string{"devicemapper", "btrfs", "aufs", "overlay", "zfs"} { dockerImagePaths[path.Join(dockerRoot, dir)] = struct{}{} } for dockerRoot != "/" && dockerRoot != "." { dockerImagePaths[dockerRoot] = struct{}{} dockerRoot = filepath.Dir(dockerRoot) } return dockerImagePaths } // This method compares the mountpoints with possible container image mount points. If a match is found, // the label is added to the partition. func (self *RealFsInfo) updateContainerImagesPath(label string, mounts []*mount.Info, containerImagePaths map[string]struct{}) { var useMount *mount.Info for _, m := range mounts { if _, ok := containerImagePaths[m.Mountpoint]; ok { if useMount == nil || (len(useMount.Mountpoint) < len(m.Mountpoint)) { useMount = m } } } if useMount != nil { self.partitions[useMount.Source] = partition{ fsType: useMount.Fstype, mountpoint: useMount.Mountpoint, major: uint(useMount.Major), minor: uint(useMount.Minor), } self.labels[label] = useMount.Source } } func (self *RealFsInfo) GetDeviceForLabel(label string) (string, error) { dev, ok := self.labels[label] if !ok { return "", fmt.Errorf("non-existent label %q", label) } return dev, nil } func (self *RealFsInfo) GetLabelsForDevice(device string) ([]string, error) { labels := []string{} for label, dev := range self.labels { if dev == device { labels = append(labels, label) } } return labels, nil } func (self *RealFsInfo) GetMountpointForDevice(dev string) (string, error) { p, ok := self.partitions[dev] if !ok { return "", fmt.Errorf("no partition info for device %q", dev) } return p.mountpoint, nil } func (self *RealFsInfo) GetFsInfoForPath(mountSet map[string]struct{}) ([]Fs, error) { filesystems := make([]Fs, 0) deviceSet := make(map[string]struct{}) diskStatsMap, err := getDiskStatsMap("/proc/diskstats") if err != nil { return nil, err } for device, partition := range self.partitions { _, hasMount := mountSet[partition.mountpoint] _, hasDevice := deviceSet[device] if mountSet == nil || (hasMount && !hasDevice) { var ( err error fs Fs ) switch partition.fsType { case DeviceMapper.String(): fs.Capacity, fs.Free, fs.Available, err = getDMStats(device, partition.blockSize) glog.V(5).Infof("got devicemapper fs capacity stats: capacity: %v free: %v available: %v:", fs.Capacity, fs.Free, fs.Available) fs.Type = DeviceMapper case ZFS.String(): fs.Capacity, fs.Free, fs.Available, err = getZfstats(device) fs.Type = ZFS default: var inodes, inodesFree uint64 fs.Capacity, fs.Free, fs.Available, inodes, inodesFree, err = getVfsStats(partition.mountpoint) fs.Inodes = &inodes fs.InodesFree = &inodesFree fs.Type = VFS } if err != nil { glog.Errorf("Stat fs failed. Error: %v", err) } else { deviceSet[device] = struct{}{} fs.DeviceInfo = DeviceInfo{ Device: device, Major: uint(partition.major), Minor: uint(partition.minor), } fs.DiskStats = diskStatsMap[device] filesystems = append(filesystems, fs) } } } return filesystems, nil } var partitionRegex = regexp.MustCompile(`^(?:(?:s|v|xv)d[a-z]+\d*|dm-\d+)$`) func getDiskStatsMap(diskStatsFile string) (map[string]DiskStats, error) { diskStatsMap := make(map[string]DiskStats) file, err := os.Open(diskStatsFile) if err != nil { if os.IsNotExist(err) { glog.Infof("not collecting filesystem statistics because file %q was not available", diskStatsFile) return diskStatsMap, nil } return nil, err } defer file.Close() scanner := bufio.NewScanner(file) for scanner.Scan() { line := scanner.Text() words := strings.Fields(line) if !partitionRegex.MatchString(words[2]) { continue } // 8 50 sdd2 40 0 280 223 7 0 22 108 0 330 330 deviceName := path.Join("/dev", words[2]) wordLength := len(words) offset := 3 var stats = make([]uint64, wordLength-offset) if len(stats) < 11 { return nil, fmt.Errorf("could not parse all 11 columns of /proc/diskstats") } var error error for i := offset; i < wordLength; i++ { stats[i-offset], error = strconv.ParseUint(words[i], 10, 64) if error != nil { return nil, error } } diskStats := DiskStats{ ReadsCompleted: stats[0], ReadsMerged: stats[1], SectorsRead: stats[2], ReadTime: stats[3], WritesCompleted: stats[4], WritesMerged: stats[5], SectorsWritten: stats[6], WriteTime: stats[7], IoInProgress: stats[8], IoTime: stats[9], WeightedIoTime: stats[10], } diskStatsMap[deviceName] = diskStats } return diskStatsMap, nil } func (self *RealFsInfo) GetGlobalFsInfo() ([]Fs, error) { return self.GetFsInfoForPath(nil) } func major(devNumber uint64) uint { return uint((devNumber >> 8) & 0xfff) } func minor(devNumber uint64) uint { return uint((devNumber & 0xff) | ((devNumber >> 12) & 0xfff00)) } func (self *RealFsInfo) GetDirFsDevice(dir string) (*DeviceInfo, error) { buf := new(syscall.Stat_t) err := syscall.Stat(dir, buf) if err != nil { return nil, fmt.Errorf("stat failed on %s with error: %s", dir, err) } major := major(buf.Dev) minor := minor(buf.Dev) for device, partition := range self.partitions { if partition.major == major && partition.minor == minor { return &DeviceInfo{device, major, minor}, nil } } return nil, fmt.Errorf("could not find device with major: %d, minor: %d in cached partitions map", major, minor) } func (self *RealFsInfo) GetDirDiskUsage(dir string, timeout time.Duration) (uint64, error) { if dir == "" { return 0, fmt.Errorf("invalid directory") } claimToken() defer releaseToken() cmd := exec.Command("nice", "-n", "19", "du", "-s", dir) stdoutp, err := cmd.StdoutPipe() if err != nil { return 0, fmt.Errorf("failed to setup stdout for cmd %v - %v", cmd.Args, err) } stderrp, err := cmd.StderrPipe() if err != nil { return 0, fmt.Errorf("failed to setup stderr for cmd %v - %v", cmd.Args, err) } if err := cmd.Start(); err != nil { return 0, fmt.Errorf("failed to exec du - %v", err) } timer := time.AfterFunc(timeout, func() { glog.Infof("killing cmd %v due to timeout(%s)", cmd.Args, timeout.String()) cmd.Process.Kill() }) stdoutb, souterr := ioutil.ReadAll(stdoutp) if souterr != nil { glog.Errorf("failed to read from stdout for cmd %v - %v", cmd.Args, souterr) } stderrb, _ := ioutil.ReadAll(stderrp) err = cmd.Wait() timer.Stop() if err != nil { return 0, fmt.Errorf("du command failed on %s with output stdout: %s, stderr: %s - %v", dir, string(stdoutb), string(stderrb), err) } stdout := string(stdoutb) usageInKb, err := strconv.ParseUint(strings.Fields(stdout)[0], 10, 64) if err != nil { return 0, fmt.Errorf("cannot parse 'du' output %s - %s", stdout, err) } return usageInKb * 1024, nil } func (self *RealFsInfo) GetDirInodeUsage(dir string, timeout time.Duration) (uint64, error) { if dir == "" { return 0, fmt.Errorf("invalid directory") } var counter byteCounter var stderr bytes.Buffer claimToken() defer releaseToken() findCmd := exec.Command("find", dir, "-xdev", "-printf", ".") findCmd.Stdout, findCmd.Stderr = &counter, &stderr if err := findCmd.Start(); err != nil { return 0, fmt.Errorf("failed to exec cmd %v - %v; stderr: %v", findCmd.Args, err, stderr.String()) } timer := time.AfterFunc(timeout, func() { glog.Infof("killing cmd %v due to timeout(%s)", findCmd.Args, timeout.String()) findCmd.Process.Kill() }) if err := findCmd.Wait(); err != nil { return 0, fmt.Errorf("cmd %v failed. stderr: %s; err: %v", findCmd.Args, stderr.String(), err) } timer.Stop() return counter.bytesWritten, nil } func getVfsStats(path string) (total uint64, free uint64, avail uint64, inodes uint64, inodesFree uint64, err error) { var s syscall.Statfs_t if err = syscall.Statfs(path, &s); err != nil { return 0, 0, 0, 0, 0, err } total = uint64(s.Frsize) * s.Blocks free = uint64(s.Frsize) * s.Bfree avail = uint64(s.Frsize) * s.Bavail inodes = uint64(s.Files) inodesFree = uint64(s.Ffree) return total, free, avail, inodes, inodesFree, nil } // Devicemapper thin provisioning is detailed at // https://www.kernel.org/doc/Documentation/device-mapper/thin-provisioning.txt func dockerDMDevice(driverStatus map[string]string, dmsetup devicemapper.DmsetupClient) (string, uint, uint, uint, error) { poolName, ok := driverStatus[dockerutil.DriverStatusPoolName] if !ok || len(poolName) == 0 { return "", 0, 0, 0, fmt.Errorf("Could not get dm pool name") } out, err := dmsetup.Table(poolName) if err != nil { return "", 0, 0, 0, err } major, minor, dataBlkSize, err := parseDMTable(string(out)) if err != nil { return "", 0, 0, 0, err } return poolName, major, minor, dataBlkSize, nil } // parseDMTable parses a single line of `dmsetup table` output and returns the // major device, minor device, block size, and an error. func parseDMTable(dmTable string) (uint, uint, uint, error) { dmTable = strings.Replace(dmTable, ":", " ", -1) dmFields := strings.Fields(dmTable) if len(dmFields) < 8 { return 0, 0, 0, fmt.Errorf("Invalid dmsetup status output: %s", dmTable) } major, err := strconv.ParseUint(dmFields[5], 10, 32) if err != nil { return 0, 0, 0, err } minor, err := strconv.ParseUint(dmFields[6], 10, 32) if err != nil { return 0, 0, 0, err } dataBlkSize, err := strconv.ParseUint(dmFields[7], 10, 32) if err != nil { return 0, 0, 0, err } return uint(major), uint(minor), uint(dataBlkSize), nil } func getDMStats(poolName string, dataBlkSize uint) (uint64, uint64, uint64, error) { out, err := exec.Command("dmsetup", "status", poolName).Output() if err != nil { return 0, 0, 0, err } used, total, err := parseDMStatus(string(out)) if err != nil { return 0, 0, 0, err } used *= 512 * uint64(dataBlkSize) total *= 512 * uint64(dataBlkSize) free := total - used return total, free, free, nil } func parseDMStatus(dmStatus string) (uint64, uint64, error) { dmStatus = strings.Replace(dmStatus, "/", " ", -1) dmFields := strings.Fields(dmStatus) if len(dmFields) < 8 { return 0, 0, fmt.Errorf("Invalid dmsetup status output: %s", dmStatus) } used, err := strconv.ParseUint(dmFields[6], 10, 64) if err != nil { return 0, 0, err } total, err := strconv.ParseUint(dmFields[7], 10, 64) if err != nil { return 0, 0, err } return used, total, nil } // getZfstats returns ZFS mount stats using zfsutils func getZfstats(poolName string) (uint64, uint64, uint64, error) { dataset, err := zfs.GetDataset(poolName) if err != nil { return 0, 0, 0, err } total := dataset.Used + dataset.Avail + dataset.Usedbydataset return total, dataset.Avail, dataset.Avail, nil } // Simple io.Writer implementation that counts how many bytes were written. type byteCounter struct{ bytesWritten uint64 } func (b *byteCounter) Write(p []byte) (int, error) { b.bytesWritten += uint64(len(p)) return len(p), nil } cadvisor-0.25.0/fs/fs_test.go000066400000000000000000000350651306035727200160340ustar00rootroot00000000000000// Copyright 2014 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package fs import ( "errors" "io/ioutil" "os" "reflect" "testing" "time" "github.com/docker/docker/pkg/mount" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestGetDiskStatsMap(t *testing.T) { diskStatsMap, err := getDiskStatsMap("test_resources/diskstats") if err != nil { t.Errorf("Error calling getDiskStatMap %s", err) } if len(diskStatsMap) != 30 { t.Errorf("diskStatsMap %+v not valid", diskStatsMap) } keySet := map[string]string{ "/dev/sda": "/dev/sda", "/dev/sdb": "/dev/sdb", "/dev/sdc": "/dev/sdc", "/dev/sdd": "/dev/sdd", "/dev/sde": "/dev/sde", "/dev/sdf": "/dev/sdf", "/dev/sdg": "/dev/sdg", "/dev/sdh": "/dev/sdh", "/dev/sdb1": "/dev/sdb1", "/dev/sdb2": "/dev/sdb2", "/dev/sda1": "/dev/sda1", "/dev/sda2": "/dev/sda2", "/dev/sdc1": "/dev/sdc1", "/dev/sdc2": "/dev/sdc2", "/dev/sdc3": "/dev/sdc3", "/dev/sdc4": "/dev/sdc4", "/dev/sdd1": "/dev/sdd1", "/dev/sdd2": "/dev/sdd2", "/dev/sdd3": "/dev/sdd3", "/dev/sdd4": "/dev/sdd4", "/dev/sde1": "/dev/sde1", "/dev/sde2": "/dev/sde2", "/dev/sdf1": "/dev/sdf1", "/dev/sdf2": "/dev/sdf2", "/dev/sdg1": "/dev/sdg1", "/dev/sdg2": "/dev/sdg2", "/dev/sdh1": "/dev/sdh1", "/dev/sdh2": "/dev/sdh2", "/dev/dm-0": "/dev/dm-0", "/dev/dm-1": "/dev/dm-1", } for device := range diskStatsMap { if _, ok := keySet[device]; !ok { t.Errorf("Cannot find device %s", device) } delete(keySet, device) } if len(keySet) != 0 { t.Errorf("diskStatsMap %+v contains illegal keys %+v", diskStatsMap, keySet) } } func TestFileNotExist(t *testing.T) { _, err := getDiskStatsMap("/file_does_not_exist") if err != nil { t.Fatalf("getDiskStatsMap must not error for absent file: %s", err) } } func TestDirDiskUsage(t *testing.T) { as := assert.New(t) fsInfo, err := NewFsInfo(Context{}) as.NoError(err) dir, err := ioutil.TempDir(os.TempDir(), "") as.NoError(err) defer os.RemoveAll(dir) dataSize := 1024 * 100 //100 KB b := make([]byte, dataSize) f, err := ioutil.TempFile(dir, "") as.NoError(err) as.NoError(ioutil.WriteFile(f.Name(), b, 0700)) fi, err := f.Stat() as.NoError(err) expectedSize := uint64(fi.Size()) size, err := fsInfo.GetDirDiskUsage(dir, time.Minute) as.NoError(err) as.True(expectedSize <= size, "expected dir size to be at-least %d; got size: %d", expectedSize, size) } func TestDirInodeUsage(t *testing.T) { as := assert.New(t) fsInfo, err := NewFsInfo(Context{}) as.NoError(err) dir, err := ioutil.TempDir(os.TempDir(), "") as.NoError(err) defer os.RemoveAll(dir) numFiles := 1000 for i := 0; i < numFiles; i++ { _, err := ioutil.TempFile(dir, "") require.NoError(t, err) } inodes, err := fsInfo.GetDirInodeUsage(dir, time.Minute) as.NoError(err) // We sould get numFiles+1 inodes, since we get 1 inode for each file, plus 1 for the directory as.True(uint64(numFiles+1) == inodes, "expected inodes in dir to be %d; got inodes: %d", numFiles+1, inodes) } var dmStatusTests = []struct { dmStatus string used uint64 total uint64 errExpected bool }{ {`0 409534464 thin-pool 64085 3705/4161600 88106/3199488 - rw no_discard_passdown queue_if_no_space -`, 88106, 3199488, false}, {`0 209715200 thin-pool 707 1215/524288 30282/1638400 - rw discard_passdown`, 30282, 1638400, false}, {`Invalid status line`, 0, 0, false}, } func TestParseDMStatus(t *testing.T) { for _, tt := range dmStatusTests { used, total, err := parseDMStatus(tt.dmStatus) if tt.errExpected && err != nil { t.Errorf("parseDMStatus(%q) expected error", tt.dmStatus) } if used != tt.used { t.Errorf("parseDMStatus(%q) wrong used value => %q, want %q", tt.dmStatus, used, tt.used) } if total != tt.total { t.Errorf("parseDMStatus(%q) wrong total value => %q, want %q", tt.dmStatus, total, tt.total) } } } var dmTableTests = []struct { dmTable string major uint minor uint dataBlkSize uint errExpected bool }{ {`0 409534464 thin-pool 253:6 253:7 128 32768 1 skip_block_zeroing`, 253, 7, 128, false}, {`0 409534464 thin-pool 253:6 258:9 512 32768 1 skip_block_zeroing otherstuff`, 258, 9, 512, false}, {`Invalid status line`, 0, 0, 0, false}, } func TestParseDMTable(t *testing.T) { for _, tt := range dmTableTests { major, minor, dataBlkSize, err := parseDMTable(tt.dmTable) if tt.errExpected && err != nil { t.Errorf("parseDMTable(%q) expected error", tt.dmTable) } if major != tt.major { t.Errorf("parseDMTable(%q) wrong major value => %q, want %q", tt.dmTable, major, tt.major) } if minor != tt.minor { t.Errorf("parseDMTable(%q) wrong minor value => %q, want %q", tt.dmTable, minor, tt.minor) } if dataBlkSize != tt.dataBlkSize { t.Errorf("parseDMTable(%q) wrong dataBlkSize value => %q, want %q", tt.dmTable, dataBlkSize, tt.dataBlkSize) } } } func TestAddSystemRootLabel(t *testing.T) { tests := []struct { mounts []*mount.Info expected string }{ { mounts: []*mount.Info{ {Source: "/dev/sda1", Mountpoint: "/foo"}, {Source: "/dev/sdb1", Mountpoint: "/"}, }, expected: "/dev/sdb1", }, } for i, tt := range tests { fsInfo := &RealFsInfo{ labels: map[string]string{}, partitions: map[string]partition{}, } fsInfo.addSystemRootLabel(tt.mounts) if source, ok := fsInfo.labels[LabelSystemRoot]; !ok || source != tt.expected { t.Errorf("case %d: expected mount source '%s', got '%s'", i, tt.expected, source) } } } type testDmsetup struct { data []byte err error } func (*testDmsetup) Message(deviceName string, sector int, message string) ([]byte, error) { return nil, nil } func (*testDmsetup) Status(deviceName string) ([]byte, error) { return nil, nil } func (t *testDmsetup) Table(poolName string) ([]byte, error) { return t.data, t.err } func TestGetDockerDeviceMapperInfo(t *testing.T) { tests := []struct { name string driver string driverStatus map[string]string dmsetupTable string dmsetupTableError error expectedDevice string expectedPartition *partition expectedError bool }{ { name: "not devicemapper", driver: "btrfs", expectedDevice: "", expectedPartition: nil, expectedError: false, }, { name: "nil driver status", driver: "devicemapper", driverStatus: nil, expectedDevice: "", expectedPartition: nil, expectedError: true, }, { name: "loopback", driver: "devicemapper", driverStatus: map[string]string{"Data loop file": "/var/lib/docker/devicemapper/devicemapper/data"}, expectedDevice: "", expectedPartition: nil, expectedError: false, }, { name: "missing pool name", driver: "devicemapper", driverStatus: map[string]string{}, expectedDevice: "", expectedPartition: nil, expectedError: true, }, { name: "error invoking dmsetup", driver: "devicemapper", driverStatus: map[string]string{"Pool Name": "vg_vagrant-docker--pool"}, dmsetupTableError: errors.New("foo"), expectedDevice: "", expectedPartition: nil, expectedError: true, }, { name: "unable to parse dmsetup table", driver: "devicemapper", driverStatus: map[string]string{"Pool Name": "vg_vagrant-docker--pool"}, dmsetupTable: "no data here!", expectedDevice: "", expectedPartition: nil, expectedError: true, }, { name: "happy path", driver: "devicemapper", driverStatus: map[string]string{"Pool Name": "vg_vagrant-docker--pool"}, dmsetupTable: "0 53870592 thin-pool 253:2 253:3 1024 0 1 skip_block_zeroing", expectedDevice: "vg_vagrant-docker--pool", expectedPartition: &partition{ fsType: "devicemapper", major: 253, minor: 3, blockSize: 1024, }, expectedError: false, }, } for _, tt := range tests { fsInfo := &RealFsInfo{ dmsetup: &testDmsetup{ data: []byte(tt.dmsetupTable), }, } dockerCtx := DockerContext{ Driver: tt.driver, DriverStatus: tt.driverStatus, } device, partition, err := fsInfo.getDockerDeviceMapperInfo(dockerCtx) if tt.expectedError && err == nil { t.Errorf("%s: expected error but got nil", tt.name) continue } if !tt.expectedError && err != nil { t.Errorf("%s: unexpected error: %v", tt.name, err) continue } if e, a := tt.expectedDevice, device; e != a { t.Errorf("%s: device: expected %q, got %q", tt.name, e, a) } if e, a := tt.expectedPartition, partition; !reflect.DeepEqual(e, a) { t.Errorf("%s: partition: expected %#v, got %#v", tt.name, e, a) } } } func TestAddDockerImagesLabel(t *testing.T) { tests := []struct { name string driver string driverStatus map[string]string dmsetupTable string getDockerDeviceMapperInfoError error mounts []*mount.Info expectedDockerDevice string expectedPartition *partition }{ { name: "devicemapper, not loopback", driver: "devicemapper", driverStatus: map[string]string{"Pool Name": "vg_vagrant-docker--pool"}, dmsetupTable: "0 53870592 thin-pool 253:2 253:3 1024 0 1 skip_block_zeroing", mounts: []*mount.Info{ { Source: "/dev/mapper/vg_vagrant-lv_root", Mountpoint: "/", Fstype: "devicemapper", }, }, expectedDockerDevice: "vg_vagrant-docker--pool", expectedPartition: &partition{ fsType: "devicemapper", major: 253, minor: 3, blockSize: 1024, }, }, { name: "devicemapper, loopback on non-root partition", driver: "devicemapper", driverStatus: map[string]string{"Data loop file": "/var/lib/docker/devicemapper/devicemapper/data"}, mounts: []*mount.Info{ { Source: "/dev/mapper/vg_vagrant-lv_root", Mountpoint: "/", Fstype: "devicemapper", }, { Source: "/dev/sdb1", Mountpoint: "/var/lib/docker/devicemapper", }, }, expectedDockerDevice: "/dev/sdb1", }, { name: "multiple mounts - innermost check", mounts: []*mount.Info{ { Source: "/dev/sda1", Mountpoint: "/", Fstype: "ext4", }, { Source: "/dev/sdb1", Mountpoint: "/var/lib/docker", Fstype: "ext4", }, { Source: "/dev/sdb2", Mountpoint: "/var/lib/docker/btrfs", Fstype: "btrfs", }, }, expectedDockerDevice: "/dev/sdb2", }, { name: "root fs inside container, docker-images bindmount", mounts: []*mount.Info{ { Source: "overlay", Mountpoint: "/", Fstype: "overlay", }, { Source: "/dev/sda1", Mountpoint: "/var/lib/docker", Fstype: "ext4", }, }, expectedDockerDevice: "/dev/sda1", }, } for _, tt := range tests { fsInfo := &RealFsInfo{ labels: map[string]string{}, partitions: map[string]partition{}, dmsetup: &testDmsetup{ data: []byte(tt.dmsetupTable), }, } context := Context{ Docker: DockerContext{ Root: "/var/lib/docker", Driver: tt.driver, DriverStatus: tt.driverStatus, }, } fsInfo.addDockerImagesLabel(context, tt.mounts) if e, a := tt.expectedDockerDevice, fsInfo.labels[LabelDockerImages]; e != a { t.Errorf("%s: docker device: expected %q, got %q", tt.name, e, a) } if tt.expectedPartition == nil { continue } if e, a := *tt.expectedPartition, fsInfo.partitions[tt.expectedDockerDevice]; !reflect.DeepEqual(e, a) { t.Errorf("%s: docker partition: expected %#v, got %#v", tt.name, e, a) } } } func TestProcessMounts(t *testing.T) { tests := []struct { name string mounts []*mount.Info excludedPrefixes []string expected map[string]partition }{ { name: "unsupported fs types", mounts: []*mount.Info{ {Fstype: "overlay"}, {Fstype: "somethingelse"}, }, expected: map[string]partition{}, }, { name: "avoid bind mounts", mounts: []*mount.Info{ {Root: "/", Mountpoint: "/", Source: "/dev/sda1", Fstype: "xfs", Major: 253, Minor: 0}, {Root: "/foo", Mountpoint: "/bar", Source: "/dev/sda1", Fstype: "xfs", Major: 253, Minor: 0}, }, expected: map[string]partition{ "/dev/sda1": {fsType: "xfs", mountpoint: "/", major: 253, minor: 0}, }, }, { name: "exclude prefixes", mounts: []*mount.Info{ {Root: "/", Mountpoint: "/someother", Source: "/dev/sda1", Fstype: "xfs", Major: 253, Minor: 2}, {Root: "/", Mountpoint: "/", Source: "/dev/sda2", Fstype: "xfs", Major: 253, Minor: 0}, {Root: "/", Mountpoint: "/excludeme", Source: "/dev/sda3", Fstype: "xfs", Major: 253, Minor: 1}, }, excludedPrefixes: []string{"/exclude", "/some"}, expected: map[string]partition{ "/dev/sda2": {fsType: "xfs", mountpoint: "/", major: 253, minor: 0}, }, }, { name: "supported fs types", mounts: []*mount.Info{ {Root: "/", Mountpoint: "/a", Source: "/dev/sda", Fstype: "ext3", Major: 253, Minor: 0}, {Root: "/", Mountpoint: "/b", Source: "/dev/sdb", Fstype: "ext4", Major: 253, Minor: 1}, {Root: "/", Mountpoint: "/c", Source: "/dev/sdc", Fstype: "btrfs", Major: 253, Minor: 2}, {Root: "/", Mountpoint: "/d", Source: "/dev/sdd", Fstype: "xfs", Major: 253, Minor: 3}, {Root: "/", Mountpoint: "/e", Source: "/dev/sde", Fstype: "zfs", Major: 253, Minor: 4}, }, expected: map[string]partition{ "/dev/sda": {fsType: "ext3", mountpoint: "/a", major: 253, minor: 0}, "/dev/sdb": {fsType: "ext4", mountpoint: "/b", major: 253, minor: 1}, "/dev/sdc": {fsType: "btrfs", mountpoint: "/c", major: 253, minor: 2}, "/dev/sdd": {fsType: "xfs", mountpoint: "/d", major: 253, minor: 3}, "/dev/sde": {fsType: "zfs", mountpoint: "/e", major: 253, minor: 4}, }, }, } for _, test := range tests { actual := processMounts(test.mounts, test.excludedPrefixes) if !reflect.DeepEqual(test.expected, actual) { t.Errorf("%s: expected %#v, got %#v", test.name, test.expected, actual) } } } cadvisor-0.25.0/fs/test_resources/000077500000000000000000000000001306035727200170765ustar00rootroot00000000000000cadvisor-0.25.0/fs/test_resources/diskstats000066400000000000000000000053361306035727200210410ustar00rootroot00000000000000 1 0 ram0 0 0 0 0 0 0 0 0 0 0 0 1 1 ram1 0 0 0 0 0 0 0 0 0 0 0 1 2 ram2 0 0 0 0 0 0 0 0 0 0 0 1 3 ram3 0 0 0 0 0 0 0 0 0 0 0 1 4 ram4 0 0 0 0 0 0 0 0 0 0 0 1 5 ram5 0 0 0 0 0 0 0 0 0 0 0 1 6 ram6 0 0 0 0 0 0 0 0 0 0 0 1 7 ram7 0 0 0 0 0 0 0 0 0 0 0 1 8 ram8 0 0 0 0 0 0 0 0 0 0 0 1 9 ram9 0 0 0 0 0 0 0 0 0 0 0 1 10 ram10 0 0 0 0 0 0 0 0 0 0 0 1 11 ram11 0 0 0 0 0 0 0 0 0 0 0 1 12 ram12 0 0 0 0 0 0 0 0 0 0 0 1 13 ram13 0 0 0 0 0 0 0 0 0 0 0 1 14 ram14 0 0 0 0 0 0 0 0 0 0 0 1 15 ram15 0 0 0 0 0 0 0 0 0 0 0 7 0 loop0 0 0 0 0 0 0 0 0 0 0 0 7 1 loop1 0 0 0 0 0 0 0 0 0 0 0 7 2 loop2 0 0 0 0 0 0 0 0 0 0 0 7 3 loop3 0 0 0 0 0 0 0 0 0 0 0 7 4 loop4 0 0 0 0 0 0 0 0 0 0 0 7 5 loop5 0 0 0 0 0 0 0 0 0 0 0 7 6 loop6 0 0 0 0 0 0 0 0 0 0 0 7 7 loop7 0 0 0 0 0 0 0 0 0 0 0 8 16 sdb 931 1157 7601 960 2 0 16 0 0 919 960 8 17 sdb1 477 1147 3895 271 1 0 8 0 0 271 271 8 18 sdb2 395 0 3154 326 1 0 8 0 0 326 326 8 0 sda 931 1157 7601 1065 2 0 16 0 0 873 1065 8 1 sda1 477 1147 3895 419 1 0 8 0 0 419 419 8 2 sda2 395 0 3154 328 1 0 8 0 0 328 328 8 32 sdc 12390 470 457965 36363 72184 244851 9824537 5359169 0 607738 5437210 8 33 sdc1 10907 221 446193 34366 72173 244851 9824499 5359063 0 606972 5435214 8 34 sdc2 650 249 5120 901 7 0 22 93 0 956 994 8 35 sdc3 264 0 2106 380 1 0 8 0 0 380 380 8 36 sdc4 392 0 3130 476 1 0 8 0 0 475 475 8 48 sdd 3371 134 58909 18327 73997 243043 9824537 4532714 0 594248 4602162 8 49 sdd1 2498 134 51977 17192 73986 243043 9824499 4532600 0 593618 4600885 8 50 sdd2 40 0 280 223 7 0 22 108 0 330 330 8 51 sdd3 264 0 2106 328 1 0 8 0 0 328 328 8 52 sdd4 392 0 3130 373 1 0 8 1 0 374 374 8 64 sde 931 1157 7601 768 2 0 16 0 0 632 768 8 65 sde1 477 1147 3895 252 1 0 8 0 0 252 252 8 66 sde2 395 0 3154 281 1 0 8 0 0 281 281 8 80 sdf 931 1157 7601 936 2 0 16 0 0 717 936 8 81 sdf1 477 1147 3895 382 1 0 8 0 0 382 382 8 82 sdf2 395 0 3154 321 1 0 8 0 0 321 321 8 96 sdg 931 1157 7601 858 2 0 16 0 0 804 858 8 97 sdg1 477 1147 3895 244 1 0 8 0 0 244 244 8 98 sdg2 395 0 3154 299 1 0 8 0 0 299 299 8 112 sdh 931 1157 7601 895 2 0 16 0 0 841 895 8 113 sdh1 477 1147 3895 264 1 0 8 0 0 264 264 8 114 sdh2 395 0 3154 311 1 0 8 0 0 311 311 252 0 dm-0 1251094 0 108121362 21287644 111848 0 52908472 22236936 0 4838500 43524784 252 1 dm-1 58415638 0 2682446960 1719953592 20048040 0 543988240 1975572544 0 262085340 3695556828 cadvisor-0.25.0/fs/types.go000066400000000000000000000044661306035727200155320ustar00rootroot00000000000000// Copyright 2014 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package fs import "time" type DeviceInfo struct { Device string Major uint Minor uint } type FsType string func (ft FsType) String() string { return string(ft) } const ( ZFS FsType = "zfs" DeviceMapper FsType = "devicemapper" VFS FsType = "vfs" ) type Fs struct { DeviceInfo Type FsType Capacity uint64 Free uint64 Available uint64 Inodes *uint64 InodesFree *uint64 DiskStats DiskStats } type DiskStats struct { ReadsCompleted uint64 ReadsMerged uint64 SectorsRead uint64 ReadTime uint64 WritesCompleted uint64 WritesMerged uint64 SectorsWritten uint64 WriteTime uint64 IoInProgress uint64 IoTime uint64 WeightedIoTime uint64 } type FsInfo interface { // Returns capacity and free space, in bytes, of all the ext2, ext3, ext4 filesystems on the host. GetGlobalFsInfo() ([]Fs, error) // Returns capacity and free space, in bytes, of the set of mounts passed. GetFsInfoForPath(mountSet map[string]struct{}) ([]Fs, error) // Returns number of bytes occupied by 'dir'. GetDirDiskUsage(dir string, timeout time.Duration) (uint64, error) // Returns number of inodes used by 'dir'. GetDirInodeUsage(dir string, timeout time.Duration) (uint64, error) // Returns the block device info of the filesystem on which 'dir' resides. GetDirFsDevice(dir string) (*DeviceInfo, error) // Returns the device name associated with a particular label. GetDeviceForLabel(label string) (string, error) // Returns all labels associated with a particular device name. GetLabelsForDevice(device string) ([]string, error) // Returns the mountpoint associated with a particular device. GetMountpointForDevice(device string) (string, error) } cadvisor-0.25.0/healthz/000077500000000000000000000000001306035727200150545ustar00rootroot00000000000000cadvisor-0.25.0/healthz/healthz.go000066400000000000000000000017201306035727200170420ustar00rootroot00000000000000// 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 healthz import ( "net/http" httpmux "github.com/google/cadvisor/http/mux" ) func handleHealthz(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusOK) w.Write([]byte("ok")) } // Register simple HTTP /healthz handler to return "ok". func RegisterHandler(mux httpmux.Mux) error { mux.HandleFunc("/healthz", handleHealthz) return nil } cadvisor-0.25.0/http/000077500000000000000000000000001306035727200143745ustar00rootroot00000000000000cadvisor-0.25.0/http/handlers.go000066400000000000000000000077241306035727200165350ustar00rootroot00000000000000// Copyright 2015 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 http import ( "fmt" "net/http" "github.com/google/cadvisor/api" "github.com/google/cadvisor/healthz" httpmux "github.com/google/cadvisor/http/mux" "github.com/google/cadvisor/manager" "github.com/google/cadvisor/metrics" "github.com/google/cadvisor/pages" "github.com/google/cadvisor/pages/static" "github.com/google/cadvisor/validate" auth "github.com/abbot/go-http-auth" "github.com/golang/glog" "github.com/prometheus/client_golang/prometheus" ) func RegisterHandlers(mux httpmux.Mux, containerManager manager.Manager, httpAuthFile, httpAuthRealm, httpDigestFile, httpDigestRealm string) error { // Basic health handler. if err := healthz.RegisterHandler(mux); err != nil { return fmt.Errorf("failed to register healthz handler: %s", err) } // Validation/Debug handler. mux.HandleFunc(validate.ValidatePage, func(w http.ResponseWriter, r *http.Request) { err := validate.HandleRequest(w, containerManager) if err != nil { fmt.Fprintf(w, "%s", err) } }) // Register API handler. if err := api.RegisterHandlers(mux, containerManager); err != nil { return fmt.Errorf("failed to register API handlers: %s", err) } // Redirect / to containers page. mux.Handle("/", http.RedirectHandler(pages.ContainersPage, http.StatusTemporaryRedirect)) var authenticated bool = false // Setup the authenticator object if httpAuthFile != "" { glog.Infof("Using auth file %s", httpAuthFile) secrets := auth.HtpasswdFileProvider(httpAuthFile) authenticator := auth.NewBasicAuthenticator(httpAuthRealm, secrets) mux.HandleFunc(static.StaticResource, authenticator.Wrap(staticHandler)) if err := pages.RegisterHandlersBasic(mux, containerManager, authenticator); err != nil { return fmt.Errorf("failed to register pages auth handlers: %s", err) } authenticated = true } if httpAuthFile == "" && httpDigestFile != "" { glog.Infof("Using digest file %s", httpDigestFile) secrets := auth.HtdigestFileProvider(httpDigestFile) authenticator := auth.NewDigestAuthenticator(httpDigestRealm, secrets) mux.HandleFunc(static.StaticResource, authenticator.Wrap(staticHandler)) if err := pages.RegisterHandlersDigest(mux, containerManager, authenticator); err != nil { return fmt.Errorf("failed to register pages digest handlers: %s", err) } authenticated = true } // Change handler based on authenticator initalization if !authenticated { mux.HandleFunc(static.StaticResource, staticHandlerNoAuth) if err := pages.RegisterHandlersBasic(mux, containerManager, nil); err != nil { return fmt.Errorf("failed to register pages handlers: %s", err) } } return nil } // RegisterPrometheusHandler creates a new PrometheusCollector, registers it // on the global registry and configures the provided HTTP mux to handle the // given Prometheus endpoint. func RegisterPrometheusHandler(mux httpmux.Mux, containerManager manager.Manager, prometheusEndpoint string, f metrics.ContainerLabelsFunc) { collector := metrics.NewPrometheusCollector(containerManager, f) prometheus.MustRegister(collector) mux.Handle(prometheusEndpoint, prometheus.Handler()) } func staticHandlerNoAuth(w http.ResponseWriter, r *http.Request) { err := static.HandleRequest(w, r.URL) if err != nil { fmt.Fprintf(w, "%s", err) } } func staticHandler(w http.ResponseWriter, r *auth.AuthenticatedRequest) { err := static.HandleRequest(w, r.URL) if err != nil { fmt.Fprintf(w, "%s", err) } } cadvisor-0.25.0/http/mux/000077500000000000000000000000001306035727200152055ustar00rootroot00000000000000cadvisor-0.25.0/http/mux/mux.go000066400000000000000000000015751306035727200163550ustar00rootroot00000000000000// Copyright 2015 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 mux import ( "net/http" ) // Mux interface expected by cAdvisor components. type Mux interface { HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request)) Handler(r *http.Request) (http.Handler, string) Handle(pattern string, handler http.Handler) } cadvisor-0.25.0/info/000077500000000000000000000000001306035727200143505ustar00rootroot00000000000000cadvisor-0.25.0/info/v1/000077500000000000000000000000001306035727200146765ustar00rootroot00000000000000cadvisor-0.25.0/info/v1/container.go000066400000000000000000000440031306035727200172100ustar00rootroot00000000000000// 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 v1 import ( "reflect" "time" ) type CpuSpec struct { Limit uint64 `json:"limit"` MaxLimit uint64 `json:"max_limit"` Mask string `json:"mask,omitempty"` Quota uint64 `json:"quota,omitempty"` Period uint64 `json:"period,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 { // Time at which the container was created. CreationTime time.Time `json:"creation_time,omitempty"` // Metadata labels associated with this container. Labels map[string]string `json:"labels,omitempty"` // Metadata envs associated with this container. Only whitelisted envs are added. Envs map[string]string `json:"envs,omitempty"` HasCpu bool `json:"has_cpu"` Cpu CpuSpec `json:"cpu,omitempty"` HasMemory bool `json:"has_memory"` Memory MemorySpec `json:"memory,omitempty"` HasNetwork bool `json:"has_network"` HasFilesystem bool `json:"has_filesystem"` // HasDiskIo when true, indicates that DiskIo stats will be available. HasDiskIo bool `json:"has_diskio"` HasCustomMetrics bool `json:"has_custom_metrics"` CustomMetrics []MetricSpec `json:"custom_metrics,omitempty"` // Image name used for this container. Image string `json:"image,omitempty"` } // Container reference contains enough information to uniquely identify a container type ContainerReference struct { // The container id Id string `json:"id,omitempty"` // The absolute name of the container. This is unique on the machine. Name string `json:"name"` // Other names by which the container is known within a certain namespace. // This is unique within that namespace. Aliases []string `json:"aliases,omitempty"` // Namespace under which the aliases of a container are unique. // An example of a namespace is "docker" for Docker containers. Namespace string `json:"namespace,omitempty"` Labels map[string]string `json:"labels,omitempty"` } // Sorts by container name. type ContainerReferenceSlice []ContainerReference func (self ContainerReferenceSlice) Len() int { return len(self) } func (self ContainerReferenceSlice) Swap(i, j int) { self[i], self[j] = self[j], self[i] } func (self ContainerReferenceSlice) Less(i, j int) bool { return self[i].Name < self[j].Name } // ContainerInfoRequest is used when users check a container info from the REST API. // It specifies how much data users want to get about a container type ContainerInfoRequest struct { // Max number of stats to return. Specify -1 for all stats currently available. // Default: 60 NumStats int `json:"num_stats,omitempty"` // Start time for which to query information. // If ommitted, the beginning of time is assumed. Start time.Time `json:"start,omitempty"` // End time for which to query information. // If ommitted, current time is assumed. End time.Time `json:"end,omitempty"` } // Returns a ContainerInfoRequest with all default values specified. func DefaultContainerInfoRequest() ContainerInfoRequest { return ContainerInfoRequest{ NumStats: 60, } } func (self *ContainerInfoRequest) Equals(other ContainerInfoRequest) bool { return self.NumStats == other.NumStats && self.Start.Equal(other.Start) && self.End.Equal(other.End) } 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"` } // TODO(vmarmol): Refactor to not need this equality comparison. // ContainerInfo may be (un)marshaled by json or other en/decoder. In that // case, the Timestamp field in each stats/sample may not be precisely // en/decoded. This will lead to small but acceptable differences between a // ContainerInfo and its encode-then-decode version. Eq() is used to compare // two ContainerInfo accepting small difference (<10ms) of Time fields. func (self *ContainerInfo) Eq(b *ContainerInfo) bool { // If both self and b are nil, then Eq() returns true if self == nil { return b == nil } if b == nil { return self == nil } // For fields other than time.Time, we will compare them precisely. // This would require that any slice should have same order. if !reflect.DeepEqual(self.ContainerReference, b.ContainerReference) { return false } if !reflect.DeepEqual(self.Subcontainers, b.Subcontainers) { return false } if !self.Spec.Eq(&b.Spec) { return false } for i, expectedStats := range b.Stats { selfStats := self.Stats[i] if !expectedStats.Eq(selfStats) { return false } } return true } func (self *ContainerSpec) Eq(b *ContainerSpec) bool { // Creation within 1s of each other. diff := self.CreationTime.Sub(b.CreationTime) if (diff > time.Second) || (diff < -time.Second) { return false } if self.HasCpu != b.HasCpu { return false } if !reflect.DeepEqual(self.Cpu, b.Cpu) { return false } if self.HasMemory != b.HasMemory { return false } if !reflect.DeepEqual(self.Memory, b.Memory) { return false } if self.HasNetwork != b.HasNetwork { return false } if self.HasFilesystem != b.HasFilesystem { return false } if self.HasDiskIo != b.HasDiskIo { return false } if self.HasCustomMetrics != b.HasCustomMetrics { return false } return true } 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 } // This mirrors kernel internal structure. type LoadStats struct { // Number of sleeping tasks. NrSleeping uint64 `json:"nr_sleeping"` // Number of running tasks. NrRunning uint64 `json:"nr_running"` // Number of tasks in stopped state NrStopped uint64 `json:"nr_stopped"` // Number of tasks in uninterruptible state NrUninterruptible uint64 `json:"nr_uninterruptible"` // Number of tasks waiting on IO NrIoWait uint64 `json:"nr_io_wait"` } // CPU usage time statistics. type CpuUsage struct { // Total CPU usage. // Unit: nanoseconds. Total uint64 `json:"total"` // Per CPU/core usage of the container. // Unit: nanoseconds. PerCpu []uint64 `json:"per_cpu_usage,omitempty"` // Time spent in user space. // Unit: nanoseconds. User uint64 `json:"user"` // Time spent in kernel space. // Unit: nanoseconds. System uint64 `json:"system"` } // Cpu Completely Fair Scheduler statistics. type CpuCFS struct { // Total number of elapsed enforcement intervals. Periods uint64 `json:"periods"` // Total number of times tasks in the cgroup have been throttled. ThrottledPeriods uint64 `json:"throttled_periods"` // Total time duration for which tasks in the cgroup have been throttled. // Unit: nanoseconds. ThrottledTime uint64 `json:"throttled_time"` } // All CPU usage metrics are cumulative from the creation of the container type CpuStats struct { Usage CpuUsage `json:"usage"` CFS CpuCFS `json:"cfs"` // Smoothed average of number of runnable threads x 1000. // We multiply by thousand to avoid using floats, but preserving precision. // Load is smoothed over the last 10 seconds. Instantaneous value can be read // from LoadStats.NrRunning. LoadAverage int32 `json:"load_average"` } type PerDiskStats struct { Major uint64 `json:"major"` Minor uint64 `json:"minor"` Stats map[string]uint64 `json:"stats"` } type DiskIoStats struct { IoServiceBytes []PerDiskStats `json:"io_service_bytes,omitempty"` IoServiced []PerDiskStats `json:"io_serviced,omitempty"` IoQueued []PerDiskStats `json:"io_queued,omitempty"` Sectors []PerDiskStats `json:"sectors,omitempty"` IoServiceTime []PerDiskStats `json:"io_service_time,omitempty"` IoWaitTime []PerDiskStats `json:"io_wait_time,omitempty"` IoMerged []PerDiskStats `json:"io_merged,omitempty"` IoTime []PerDiskStats `json:"io_time,omitempty"` } type MemoryStats struct { // Current memory usage, this includes all memory regardless of when it was // accessed. // Units: Bytes. Usage uint64 `json:"usage"` // Number of bytes of page cache memory. // Units: Bytes. Cache uint64 `json:"cache"` // The amount of anonymous and swap cache memory (includes transparent // hugepages). // Units: Bytes. RSS uint64 `json:"rss"` // The amount of swap currently used by the processes in this cgroup // Units: Bytes. Swap uint64 `json:"swap"` // 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"` Failcnt uint64 `json:"failcnt"` ContainerData MemoryStatsMemoryData `json:"container_data,omitempty"` HierarchicalData MemoryStatsMemoryData `json:"hierarchical_data,omitempty"` } type MemoryStatsMemoryData struct { Pgfault uint64 `json:"pgfault"` Pgmajfault uint64 `json:"pgmajfault"` } type InterfaceStats struct { // The name of the interface. Name string `json:"name"` // Cumulative count of bytes received. RxBytes uint64 `json:"rx_bytes"` // Cumulative count of packets received. RxPackets uint64 `json:"rx_packets"` // Cumulative count of receive errors encountered. RxErrors uint64 `json:"rx_errors"` // Cumulative count of packets dropped while receiving. RxDropped uint64 `json:"rx_dropped"` // Cumulative count of bytes transmitted. TxBytes uint64 `json:"tx_bytes"` // Cumulative count of packets transmitted. TxPackets uint64 `json:"tx_packets"` // Cumulative count of transmit errors encountered. TxErrors uint64 `json:"tx_errors"` // Cumulative count of packets dropped while transmitting. TxDropped uint64 `json:"tx_dropped"` } type NetworkStats struct { InterfaceStats `json:",inline"` Interfaces []InterfaceStats `json:"interfaces,omitempty"` // TCP connection stats (Established, Listen...) Tcp TcpStat `json:"tcp"` // TCP6 connection stats (Established, Listen...) Tcp6 TcpStat `json:"tcp6"` } type TcpStat struct { // Count of TCP connections in state "Established" Established uint64 // Count of TCP connections in state "Syn_Sent" SynSent uint64 // Count of TCP connections in state "Syn_Recv" SynRecv uint64 // Count of TCP connections in state "Fin_Wait1" FinWait1 uint64 // Count of TCP connections in state "Fin_Wait2" FinWait2 uint64 // Count of TCP connections in state "Time_Wait TimeWait uint64 // Count of TCP connections in state "Close" Close uint64 // Count of TCP connections in state "Close_Wait" CloseWait uint64 // Count of TCP connections in state "Listen_Ack" LastAck uint64 // Count of TCP connections in state "Listen" Listen uint64 // Count of TCP connections in state "Closing" Closing uint64 } type FsStats struct { // The block device name associated with the filesystem. Device string `json:"device,omitempty"` // Type of the filesytem. Type string `json:"type"` // Number of bytes that can be consumed by the container on this filesystem. Limit uint64 `json:"capacity"` // Number of bytes that is consumed by the container on this filesystem. Usage uint64 `json:"usage"` // Base Usage that is consumed by the container's writable layer. // This field is only applicable for docker container's as of now. BaseUsage uint64 `json:"base_usage"` // Number of bytes available for non-root user. Available uint64 `json:"available"` // HasInodes when true, indicates that Inodes info will be available. HasInodes bool `json:"has_inodes"` // Number of Inodes Inodes uint64 `json:"inodes"` // Number of available Inodes InodesFree uint64 `json:"inodes_free"` // Number of reads completed // This is the total number of reads completed successfully. ReadsCompleted uint64 `json:"reads_completed"` // Number of reads merged // Reads and writes which are adjacent to each other may be merged for // efficiency. Thus two 4K reads may become one 8K read before it is // ultimately handed to the disk, and so it will be counted (and queued) // as only one I/O. This field lets you know how often this was done. ReadsMerged uint64 `json:"reads_merged"` // Number of sectors read // This is the total number of sectors read successfully. SectorsRead uint64 `json:"sectors_read"` // Number of milliseconds spent reading // This is the total number of milliseconds spent by all reads (as // measured from __make_request() to end_that_request_last()). ReadTime uint64 `json:"read_time"` // Number of writes completed // This is the total number of writes completed successfully. WritesCompleted uint64 `json:"writes_completed"` // Number of writes merged // See the description of reads merged. WritesMerged uint64 `json:"writes_merged"` // Number of sectors written // This is the total number of sectors written successfully. SectorsWritten uint64 `json:"sectors_written"` // Number of milliseconds spent writing // This is the total number of milliseconds spent by all writes (as // measured from __make_request() to end_that_request_last()). WriteTime uint64 `json:"write_time"` // Number of I/Os currently in progress // The only field that should go to zero. Incremented as requests are // given to appropriate struct request_queue and decremented as they finish. IoInProgress uint64 `json:"io_in_progress"` // Number of milliseconds spent doing I/Os // This field increases so long as field 9 is nonzero. IoTime uint64 `json:"io_time"` // weighted number of milliseconds spent doing I/Os // This field is incremented at each I/O start, I/O completion, I/O // merge, or read of these stats by the number of I/Os in progress // (field 9) times the number of milliseconds spent doing I/O since the // last update of this field. This can provide an easy measure of both // I/O completion time and the backlog that may be accumulating. WeightedIoTime uint64 `json:"weighted_io_time"` } type ContainerStats struct { // The time of this stat point. Timestamp time.Time `json:"timestamp"` Cpu CpuStats `json:"cpu,omitempty"` DiskIo DiskIoStats `json:"diskio,omitempty"` Memory MemoryStats `json:"memory,omitempty"` Network NetworkStats `json:"network,omitempty"` // Filesystem statistics Filesystem []FsStats `json:"filesystem,omitempty"` // Task load stats TaskStats LoadStats `json:"task_stats,omitempty"` // Custom metrics from all collectors CustomMetrics map[string][]MetricVal `json:"custom_metrics,omitempty"` } func timeEq(t1, t2 time.Time, tolerance time.Duration) bool { // t1 should not be later than t2 if t1.After(t2) { t1, t2 = t2, t1 } diff := t2.Sub(t1) if diff <= tolerance { return true } return false } const ( // 10ms, i.e. 0.01s timePrecision time.Duration = 10 * time.Millisecond ) // This function is useful because we do not require precise time // representation. func (a *ContainerStats) Eq(b *ContainerStats) bool { if !timeEq(a.Timestamp, b.Timestamp, timePrecision) { return false } return a.StatsEq(b) } // Checks equality of the stats values. func (a *ContainerStats) StatsEq(b *ContainerStats) bool { // TODO(vmarmol): Consider using this through reflection. if !reflect.DeepEqual(a.Cpu, b.Cpu) { return false } if !reflect.DeepEqual(a.Memory, b.Memory) { return false } if !reflect.DeepEqual(a.DiskIo, b.DiskIo) { return false } if !reflect.DeepEqual(a.Network, b.Network) { return false } if !reflect.DeepEqual(a.Filesystem, b.Filesystem) { return false } return true } // Event contains information general to events such as the time at which they // occurred, their specific type, and the actual event. Event types are // differentiated by the EventType field of Event. type Event struct { // the absolute container name for which the event occurred ContainerName string `json:"container_name"` // the time at which the event occurred Timestamp time.Time `json:"timestamp"` // the type of event. EventType is an enumerated type EventType EventType `json:"event_type"` // the original event object and all of its extraneous data, ex. an // OomInstance EventData EventData `json:"event_data,omitempty"` } // EventType is an enumerated type which lists the categories under which // events may fall. The Event field EventType is populated by this enum. type EventType string const ( EventOom EventType = "oom" EventOomKill = "oomKill" EventContainerCreation = "containerCreation" EventContainerDeletion = "containerDeletion" ) // Extra information about an event. Only one type will be set. type EventData struct { // Information about an OOM kill event. OomKill *OomKillEventData `json:"oom,omitempty"` } // Information related to an OOM kill instance type OomKillEventData struct { // process id of the killed process Pid int `json:"pid"` // The name of the killed process ProcessName string `json:"process_name"` } cadvisor-0.25.0/info/v1/container_test.go000066400000000000000000000037201306035727200202500ustar00rootroot00000000000000// 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 v1 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 createStats(cpuUsage, memUsage uint64, timestamp time.Time) *ContainerStats { stats := &ContainerStats{} 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 } cadvisor-0.25.0/info/v1/docker.go000066400000000000000000000027261306035727200165030ustar00rootroot00000000000000// Copyright 2016 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Types used for docker containers. package v1 type DockerStatus struct { Version string `json:"version"` KernelVersion string `json:"kernel_version"` OS string `json:"os"` Hostname string `json:"hostname"` RootDir string `json:"root_dir"` Driver string `json:"driver"` DriverStatus map[string]string `json:"driver_status"` ExecDriver string `json:"exec_driver"` NumImages int `json:"num_images"` NumContainers int `json:"num_containers"` } type DockerImage struct { ID string `json:"id"` RepoTags []string `json:"repo_tags"` // repository name and tags. Created int64 `json:"created"` // unix time since creation. VirtualSize int64 `json:"virtual_size"` Size int64 `json:"size"` } cadvisor-0.25.0/info/v1/machine.go000066400000000000000000000117061306035727200166360ustar00rootroot00000000000000// 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 v1 type FsInfo struct { // Block device associated with the filesystem. Device string `json:"device"` // Total number of bytes available on the filesystem. Capacity uint64 `json:"capacity"` // Type of device. Type string `json:"type"` // Total number of inodes available on the filesystem. Inodes uint64 `json:"inodes"` // HasInodes when true, indicates that Inodes info will be available. HasInodes bool `json:"has_inodes"` } type Node struct { Id int `json:"node_id"` // Per-node memory Memory uint64 `json:"memory"` Cores []Core `json:"cores"` Caches []Cache `json:"caches"` } type Core struct { Id int `json:"core_id"` Threads []int `json:"thread_ids"` Caches []Cache `json:"caches"` } type Cache struct { // Size of memory cache in bytes. Size uint64 `json:"size"` // Type of memory cache: data, instruction, or unified. Type string `json:"type"` // Level (distance from cpus) in a multi-level cache hierarchy. Level int `json:"level"` } func (self *Node) FindCore(id int) (bool, int) { for i, n := range self.Cores { if n.Id == id { return true, i } } return false, -1 } func (self *Node) AddThread(thread int, core int) { var coreIdx int if core == -1 { // Assume one hyperthread per core when topology data is missing. core = thread } ok, coreIdx := self.FindCore(core) if !ok { // New core core := Core{Id: core} self.Cores = append(self.Cores, core) coreIdx = len(self.Cores) - 1 } self.Cores[coreIdx].Threads = append(self.Cores[coreIdx].Threads, thread) } func (self *Node) AddNodeCache(c Cache) { self.Caches = append(self.Caches, c) } func (self *Node) AddPerCoreCache(c Cache) { for idx := range self.Cores { self.Cores[idx].Caches = append(self.Cores[idx].Caches, c) } } type DiskInfo struct { // device name Name string `json:"name"` // Major number Major uint64 `json:"major"` // Minor number Minor uint64 `json:"minor"` // Size in bytes Size uint64 `json:"size"` // I/O Scheduler - one of "none", "noop", "cfq", "deadline" Scheduler string `json:"scheduler"` } type NetInfo struct { // Device name Name string `json:"name"` // Mac Address MacAddress string `json:"mac_address"` // Speed in MBits/s Speed int64 `json:"speed"` // Maximum Transmission Unit Mtu int64 `json:"mtu"` } type CloudProvider string const ( GCE CloudProvider = "GCE" AWS = "AWS" Azure = "Azure" Baremetal = "Baremetal" UnknownProvider = "Unknown" ) type InstanceType string const ( NoInstance InstanceType = "None" UnknownInstance = "Unknown" ) type InstanceID string const ( UnNamedInstance InstanceID = "None" ) type MachineInfo struct { // The number of cores in this machine. NumCores int `json:"num_cores"` // Maximum clock speed for the cores, in KHz. CpuFrequency uint64 `json:"cpu_frequency_khz"` // The amount of memory (in bytes) in this machine MemoryCapacity uint64 `json:"memory_capacity"` // The machine id MachineID string `json:"machine_id"` // The system uuid SystemUUID string `json:"system_uuid"` // The boot id BootID string `json:"boot_id"` // Filesystems on this machine. Filesystems []FsInfo `json:"filesystems"` // Disk map DiskMap map[string]DiskInfo `json:"disk_map"` // Network devices NetworkDevices []NetInfo `json:"network_devices"` // Machine Topology // Describes cpu/memory layout and hierarchy. Topology []Node `json:"topology"` // Cloud provider the machine belongs to. CloudProvider CloudProvider `json:"cloud_provider"` // Type of cloud instance (e.g. GCE standard) the machine is. InstanceType InstanceType `json:"instance_type"` // ID of cloud instance (e.g. instance-1) given to it by the cloud provider. InstanceID InstanceID `json:"instance_id"` } 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"` // cAdvisor git revision. CadvisorRevision string `json:"cadvisor_revision"` } type MachineInfoFactory interface { GetMachineInfo() (*MachineInfo, error) GetVersionInfo() (*VersionInfo, error) } cadvisor-0.25.0/info/v1/metric.go000066400000000000000000000037401306035727200165140ustar00rootroot00000000000000// Copyright 2015 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 v1 import ( "time" ) // Type of metric being exported. type MetricType string const ( // Instantaneous value. May increase or decrease. MetricGauge MetricType = "gauge" // A counter-like value that is only expected to increase. MetricCumulative MetricType = "cumulative" // Rate over a time period. MetricDelta MetricType = "delta" ) // DataType for metric being exported. type DataType string const ( IntType DataType = "int" FloatType DataType = "float" ) // Spec for custom metric. type MetricSpec struct { // The name of the metric. Name string `json:"name"` // Type of the metric. Type MetricType `json:"type"` // Data Type for the stats. Format DataType `json:"format"` // Display Units for the stats. Units string `json:"units"` } // An exported metric. type MetricValBasic struct { // Time at which the metric was queried Timestamp time.Time `json:"timestamp"` // The value of the metric at this point. IntValue int64 `json:"int_value,omitempty"` FloatValue float64 `json:"float_value,omitempty"` } // An exported metric. type MetricVal struct { // Label associated with a metric Label string `json:"label,omitempty"` // Time at which the metric was queried Timestamp time.Time `json:"timestamp"` // The value of the metric at this point. IntValue int64 `json:"int_value,omitempty"` FloatValue float64 `json:"float_value,omitempty"` } cadvisor-0.25.0/info/v1/test/000077500000000000000000000000001306035727200156555ustar00rootroot00000000000000cadvisor-0.25.0/info/v1/test/datagen.go000066400000000000000000000047151306035727200176160ustar00rootroot00000000000000// 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 ( "fmt" "math/rand" "time" info "github.com/google/cadvisor/info/v1" ) func GenerateRandomStats(numStats, numCores int, duration time.Duration) []*info.ContainerStats { ret := make([]*info.ContainerStats, numStats) perCoreUsages := make([]uint64, numCores) currentTime := time.Now() for i := range perCoreUsages { perCoreUsages[i] = uint64(rand.Int63n(1000)) } for i := 0; i < numStats; i++ { stats := new(info.ContainerStats) stats.Timestamp = currentTime currentTime = currentTime.Add(duration) percore := make([]uint64, numCores) for i := range perCoreUsages { perCoreUsages[i] += uint64(rand.Int63n(1000)) percore[i] = perCoreUsages[i] stats.Cpu.Usage.Total += percore[i] } stats.Cpu.Usage.PerCpu = percore stats.Cpu.Usage.User = stats.Cpu.Usage.Total stats.Cpu.Usage.System = 0 stats.Memory.Usage = uint64(rand.Int63n(4096)) stats.Memory.Cache = uint64(rand.Int63n(4096)) stats.Memory.RSS = uint64(rand.Int63n(4096)) ret[i] = stats } return ret } func GenerateRandomContainerSpec(numCores int) info.ContainerSpec { ret := info.ContainerSpec{ CreationTime: time.Now(), HasCpu: true, Cpu: info.CpuSpec{}, HasMemory: true, Memory: info.MemorySpec{}, } ret.Cpu.Limit = uint64(1000 + rand.Int63n(2000)) ret.Cpu.MaxLimit = uint64(1000 + rand.Int63n(2000)) ret.Cpu.Mask = fmt.Sprintf("0-%d", numCores-1) ret.Memory.Limit = uint64(4096 + rand.Int63n(4096)) return ret } func GenerateRandomContainerInfo(containerName string, numCores int, query *info.ContainerInfoRequest, duration time.Duration) *info.ContainerInfo { stats := GenerateRandomStats(query.NumStats, numCores, duration) spec := GenerateRandomContainerSpec(numCores) ret := &info.ContainerInfo{ ContainerReference: info.ContainerReference{ Name: containerName, }, Spec: spec, Stats: stats, } return ret } cadvisor-0.25.0/info/v2/000077500000000000000000000000001306035727200146775ustar00rootroot00000000000000cadvisor-0.25.0/info/v2/container.go000066400000000000000000000231331306035727200172120ustar00rootroot00000000000000// Copyright 2015 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 v2 import ( "time" // TODO(rjnagal): Remove dependency after moving all stats structs from v1. // using v1 now for easy conversion. "github.com/google/cadvisor/info/v1" ) const ( TypeName = "name" TypeDocker = "docker" ) type CpuSpec struct { // Requested cpu shares. Default is 1024. Limit uint64 `json:"limit"` // Requested cpu hard limit. Default is unlimited (0). // Units: milli-cpus. MaxLimit uint64 `json:"max_limit"` // Cpu affinity mask. // TODO(rjnagal): Add a library to convert mask string to set of cpu bitmask. Mask string `json:"mask,omitempty"` // CPUQuota Default is disabled Quota uint64 `json:"quota,omitempty"` // Period is the CPU reference time in ns e.g the quota is compared aginst this. Period uint64 `json:"period,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 ContainerInfo struct { // Describes the container. Spec ContainerSpec `json:"spec,omitempty"` // Historical statistics gathered from the container. Stats []*ContainerStats `json:"stats,omitempty"` } type ContainerSpec struct { // Time at which the container was created. CreationTime time.Time `json:"creation_time,omitempty"` // Other names by which the container is known within a certain namespace. // This is unique within that namespace. Aliases []string `json:"aliases,omitempty"` // Namespace under which the aliases of a container are unique. // An example of a namespace is "docker" for Docker containers. Namespace string `json:"namespace,omitempty"` // Metadata labels associated with this container. Labels map[string]string `json:"labels,omitempty"` // Metadata envs associated with this container. Only whitelisted envs are added. Envs map[string]string `json:"envs,omitempty"` HasCpu bool `json:"has_cpu"` Cpu CpuSpec `json:"cpu,omitempty"` HasMemory bool `json:"has_memory"` Memory MemorySpec `json:"memory,omitempty"` HasCustomMetrics bool `json:"has_custom_metrics"` CustomMetrics []v1.MetricSpec `json:"custom_metrics,omitempty"` // Following resources have no associated spec, but are being isolated. HasNetwork bool `json:"has_network"` HasFilesystem bool `json:"has_filesystem"` HasDiskIo bool `json:"has_diskio"` // Image name used for this container. Image string `json:"image,omitempty"` } type DeprecatedContainerStats struct { // The time of this stat point. Timestamp time.Time `json:"timestamp"` // CPU statistics HasCpu bool `json:"has_cpu"` // In nanoseconds (aggregated) Cpu v1.CpuStats `json:"cpu,omitempty"` // In nanocores per second (instantaneous) CpuInst *CpuInstStats `json:"cpu_inst,omitempty"` // Disk IO statistics HasDiskIo bool `json:"has_diskio"` DiskIo v1.DiskIoStats `json:"diskio,omitempty"` // Memory statistics HasMemory bool `json:"has_memory"` Memory v1.MemoryStats `json:"memory,omitempty"` // Network statistics HasNetwork bool `json:"has_network"` Network NetworkStats `json:"network,omitempty"` // Filesystem statistics HasFilesystem bool `json:"has_filesystem"` Filesystem []v1.FsStats `json:"filesystem,omitempty"` // Task load statistics HasLoad bool `json:"has_load"` Load v1.LoadStats `json:"load_stats,omitempty"` // Custom Metrics HasCustomMetrics bool `json:"has_custom_metrics"` CustomMetrics map[string][]v1.MetricVal `json:"custom_metrics,omitempty"` } type ContainerStats struct { // The time of this stat point. Timestamp time.Time `json:"timestamp"` // CPU statistics // In nanoseconds (aggregated) Cpu *v1.CpuStats `json:"cpu,omitempty"` // In nanocores per second (instantaneous) CpuInst *CpuInstStats `json:"cpu_inst,omitempty"` // Disk IO statistics DiskIo *v1.DiskIoStats `json:"diskio,omitempty"` // Memory statistics Memory *v1.MemoryStats `json:"memory,omitempty"` // Network statistics Network *NetworkStats `json:"network,omitempty"` // Filesystem statistics Filesystem *FilesystemStats `json:"filesystem,omitempty"` // Task load statistics Load *v1.LoadStats `json:"load_stats,omitempty"` // Custom Metrics CustomMetrics map[string][]v1.MetricVal `json:"custom_metrics,omitempty"` } type Percentiles struct { // Indicates whether the stats are present or not. // If true, values below do not have any data. Present bool `json:"present"` // Average over the collected sample. Mean uint64 `json:"mean"` // Max seen over the collected sample. Max uint64 `json:"max"` // 50th percentile over the collected sample. Fifty uint64 `json:"fifty"` // 90th percentile over the collected sample. Ninety uint64 `json:"ninety"` // 95th percentile over the collected sample. NinetyFive uint64 `json:"ninetyfive"` } type Usage struct { // Indicates amount of data available [0-100]. // If we have data for half a day, we'll still process DayUsage, // but set PercentComplete to 50. PercentComplete int32 `json:"percent_complete"` // Mean, Max, and 90p cpu rate value in milliCpus/seconds. Converted to milliCpus to avoid floats. Cpu Percentiles `json:"cpu"` // Mean, Max, and 90p memory size in bytes. Memory Percentiles `json:"memory"` } // latest sample collected for a container. type InstantUsage struct { // cpu rate in cpu milliseconds/second. Cpu uint64 `json:"cpu"` // Memory usage in bytes. Memory uint64 `json:"memory"` } type DerivedStats struct { // Time of generation of these stats. Timestamp time.Time `json:"timestamp"` // Latest instantaneous sample. LatestUsage InstantUsage `json:"latest_usage"` // Percentiles in last observed minute. MinuteUsage Usage `json:"minute_usage"` // Percentile in last hour. HourUsage Usage `json:"hour_usage"` // Percentile in last day. DayUsage Usage `json:"day_usage"` } type FsInfo struct { // The block device name associated with the filesystem. Device string `json:"device"` // Path where the filesystem is mounted. Mountpoint string `json:"mountpoint"` // Filesystem usage in bytes. Capacity uint64 `json:"capacity"` // Bytes available for non-root use. Available uint64 `json:"available"` // Number of bytes used on this filesystem. Usage uint64 `json:"usage"` // Labels associated with this filesystem. Labels []string `json:"labels"` // Number of Inodes. Inodes *uint64 `json:"inodes,omitempty"` // Number of available Inodes (if known) InodesFree *uint64 `json:"inodes_free,omitempty"` } type RequestOptions struct { // Type of container identifier specified - "name", "dockerid", dockeralias" IdType string `json:"type"` // Number of stats to return Count int `json:"count"` // Whether to include stats for child subcontainers. Recursive bool `json:"recursive"` } type ProcessInfo struct { User string `json:"user"` Pid int `json:"pid"` Ppid int `json:"parent_pid"` StartTime string `json:"start_time"` PercentCpu float32 `json:"percent_cpu"` PercentMemory float32 `json:"percent_mem"` RSS uint64 `json:"rss"` VirtualSize uint64 `json:"virtual_size"` Status string `json:"status"` RunningTime string `json:"running_time"` CgroupPath string `json:"cgroup_path"` Cmd string `json:"cmd"` } type TcpStat struct { Established uint64 SynSent uint64 SynRecv uint64 FinWait1 uint64 FinWait2 uint64 TimeWait uint64 Close uint64 CloseWait uint64 LastAck uint64 Listen uint64 Closing uint64 } type NetworkStats struct { // Network stats by interface. Interfaces []v1.InterfaceStats `json:"interfaces,omitempty"` // TCP connection stats (Established, Listen...) Tcp TcpStat `json:"tcp"` // TCP6 connection stats (Established, Listen...) Tcp6 TcpStat `json:"tcp6"` } // Instantaneous CPU stats type CpuInstStats struct { Usage CpuInstUsage `json:"usage"` } // CPU usage time statistics. type CpuInstUsage struct { // Total CPU usage. // Units: nanocores per second Total uint64 `json:"total"` // Per CPU/core usage of the container. // Unit: nanocores per second PerCpu []uint64 `json:"per_cpu_usage,omitempty"` // Time spent in user space. // Unit: nanocores per second User uint64 `json:"user"` // Time spent in kernel space. // Unit: nanocores per second System uint64 `json:"system"` } // Filesystem usage statistics. type FilesystemStats struct { // Total Number of bytes consumed by container. TotalUsageBytes *uint64 `json:"totalUsageBytes,omitempty"` // Number of bytes consumed by a container through its root filesystem. BaseUsageBytes *uint64 `json:"baseUsageBytes,omitempty"` // Number of inodes used within the container's root filesystem. // This only accounts for inodes that are shared across containers, // and does not include inodes used in mounted directories. InodeUsage *uint64 `json:"containter_inode_usage,omitempty"` } cadvisor-0.25.0/info/v2/conversion.go000066400000000000000000000200601306035727200174110ustar00rootroot00000000000000// Copyright 2015 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 v2 import ( "fmt" "time" "github.com/golang/glog" "github.com/google/cadvisor/info/v1" ) func machineFsStatsFromV1(fsStats []v1.FsStats) []MachineFsStats { var result []MachineFsStats for i := range fsStats { stat := fsStats[i] readDuration := time.Millisecond * time.Duration(stat.ReadTime) writeDuration := time.Millisecond * time.Duration(stat.WriteTime) ioDuration := time.Millisecond * time.Duration(stat.IoTime) weightedDuration := time.Millisecond * time.Duration(stat.WeightedIoTime) machineFsStat := MachineFsStats{ Device: stat.Device, Type: stat.Type, Capacity: &stat.Limit, Usage: &stat.Usage, Available: &stat.Available, DiskStats: DiskStats{ ReadsCompleted: &stat.ReadsCompleted, ReadsMerged: &stat.ReadsMerged, SectorsRead: &stat.SectorsRead, ReadDuration: &readDuration, WritesCompleted: &stat.WritesCompleted, WritesMerged: &stat.WritesMerged, SectorsWritten: &stat.SectorsWritten, WriteDuration: &writeDuration, IoInProgress: &stat.IoInProgress, IoDuration: &ioDuration, WeightedIoDuration: &weightedDuration, }, } if stat.HasInodes { machineFsStat.InodesFree = &stat.InodesFree } result = append(result, machineFsStat) } return result } func MachineStatsFromV1(cont *v1.ContainerInfo) []MachineStats { var stats []MachineStats var last *v1.ContainerStats for i := range cont.Stats { val := cont.Stats[i] stat := MachineStats{ Timestamp: val.Timestamp, } if cont.Spec.HasCpu { stat.Cpu = &val.Cpu cpuInst, err := InstCpuStats(last, val) if err != nil { glog.Warningf("Could not get instant cpu stats: %v", err) } else { stat.CpuInst = cpuInst } last = val } if cont.Spec.HasMemory { stat.Memory = &val.Memory } if cont.Spec.HasNetwork { stat.Network = &NetworkStats{ // FIXME: Use reflection instead. Tcp: TcpStat(val.Network.Tcp), Tcp6: TcpStat(val.Network.Tcp6), Interfaces: val.Network.Interfaces, } } if cont.Spec.HasFilesystem { stat.Filesystem = machineFsStatsFromV1(val.Filesystem) } // TODO(rjnagal): Handle load stats. stats = append(stats, stat) } return stats } func ContainerStatsFromV1(containerName string, spec *v1.ContainerSpec, stats []*v1.ContainerStats) []*ContainerStats { newStats := make([]*ContainerStats, 0, len(stats)) var last *v1.ContainerStats for _, val := range stats { stat := &ContainerStats{ Timestamp: val.Timestamp, } if spec.HasCpu { stat.Cpu = &val.Cpu cpuInst, err := InstCpuStats(last, val) if err != nil { glog.Warningf("Could not get instant cpu stats: %v", err) } else { stat.CpuInst = cpuInst } last = val } if spec.HasMemory { stat.Memory = &val.Memory } if spec.HasNetwork { // TODO: Handle TcpStats stat.Network = &NetworkStats{ Tcp: TcpStat(val.Network.Tcp), Tcp6: TcpStat(val.Network.Tcp6), Interfaces: val.Network.Interfaces, } } if spec.HasFilesystem { if len(val.Filesystem) == 1 { stat.Filesystem = &FilesystemStats{ TotalUsageBytes: &val.Filesystem[0].Usage, BaseUsageBytes: &val.Filesystem[0].BaseUsage, InodeUsage: &val.Filesystem[0].Inodes, } } else if len(val.Filesystem) > 1 && containerName != "/" { // Cannot handle multiple devices per container. glog.V(2).Infof("failed to handle multiple devices for container %s. Skipping Filesystem stats", containerName) } } if spec.HasDiskIo { stat.DiskIo = &val.DiskIo } if spec.HasCustomMetrics { stat.CustomMetrics = val.CustomMetrics } // TODO(rjnagal): Handle load stats. newStats = append(newStats, stat) } return newStats } func DeprecatedStatsFromV1(cont *v1.ContainerInfo) []DeprecatedContainerStats { stats := make([]DeprecatedContainerStats, 0, len(cont.Stats)) var last *v1.ContainerStats for _, val := range cont.Stats { stat := DeprecatedContainerStats{ Timestamp: val.Timestamp, HasCpu: cont.Spec.HasCpu, HasMemory: cont.Spec.HasMemory, HasNetwork: cont.Spec.HasNetwork, HasFilesystem: cont.Spec.HasFilesystem, HasDiskIo: cont.Spec.HasDiskIo, HasCustomMetrics: cont.Spec.HasCustomMetrics, } if stat.HasCpu { stat.Cpu = val.Cpu cpuInst, err := InstCpuStats(last, val) if err != nil { glog.Warningf("Could not get instant cpu stats: %v", err) } else { stat.CpuInst = cpuInst } last = val } if stat.HasMemory { stat.Memory = val.Memory } if stat.HasNetwork { stat.Network.Interfaces = val.Network.Interfaces } if stat.HasFilesystem { stat.Filesystem = val.Filesystem } if stat.HasDiskIo { stat.DiskIo = val.DiskIo } if stat.HasCustomMetrics { stat.CustomMetrics = val.CustomMetrics } // TODO(rjnagal): Handle load stats. stats = append(stats, stat) } return stats } func InstCpuStats(last, cur *v1.ContainerStats) (*CpuInstStats, error) { if last == nil { return nil, nil } if !cur.Timestamp.After(last.Timestamp) { return nil, fmt.Errorf("container stats move backwards in time") } if len(last.Cpu.Usage.PerCpu) != len(cur.Cpu.Usage.PerCpu) { return nil, fmt.Errorf("different number of cpus") } timeDelta := cur.Timestamp.Sub(last.Timestamp) if timeDelta <= 100*time.Millisecond { return nil, fmt.Errorf("time delta unexpectedly small") } // Nanoseconds to gain precision and avoid having zero seconds if the // difference between the timestamps is just under a second timeDeltaNs := uint64(timeDelta.Nanoseconds()) convertToRate := func(lastValue, curValue uint64) (uint64, error) { if curValue < lastValue { return 0, fmt.Errorf("cumulative stats decrease") } valueDelta := curValue - lastValue // Use float64 to keep precision return uint64(float64(valueDelta) / float64(timeDeltaNs) * 1e9), nil } total, err := convertToRate(last.Cpu.Usage.Total, cur.Cpu.Usage.Total) if err != nil { return nil, err } percpu := make([]uint64, len(last.Cpu.Usage.PerCpu)) for i := range percpu { var err error percpu[i], err = convertToRate(last.Cpu.Usage.PerCpu[i], cur.Cpu.Usage.PerCpu[i]) if err != nil { return nil, err } } user, err := convertToRate(last.Cpu.Usage.User, cur.Cpu.Usage.User) if err != nil { return nil, err } system, err := convertToRate(last.Cpu.Usage.System, cur.Cpu.Usage.System) if err != nil { return nil, err } return &CpuInstStats{ Usage: CpuInstUsage{ Total: total, PerCpu: percpu, User: user, System: system, }, }, nil } // Get V2 container spec from v1 container info. func ContainerSpecFromV1(specV1 *v1.ContainerSpec, aliases []string, namespace string) ContainerSpec { specV2 := ContainerSpec{ CreationTime: specV1.CreationTime, HasCpu: specV1.HasCpu, HasMemory: specV1.HasMemory, HasFilesystem: specV1.HasFilesystem, HasNetwork: specV1.HasNetwork, HasDiskIo: specV1.HasDiskIo, HasCustomMetrics: specV1.HasCustomMetrics, Image: specV1.Image, Labels: specV1.Labels, } if specV1.HasCpu { specV2.Cpu.Limit = specV1.Cpu.Limit specV2.Cpu.MaxLimit = specV1.Cpu.MaxLimit specV2.Cpu.Mask = specV1.Cpu.Mask } if specV1.HasMemory { specV2.Memory.Limit = specV1.Memory.Limit specV2.Memory.Reservation = specV1.Memory.Reservation specV2.Memory.SwapLimit = specV1.Memory.SwapLimit } if specV1.HasCustomMetrics { specV2.CustomMetrics = specV1.CustomMetrics } specV2.Aliases = aliases specV2.Namespace = namespace return specV2 } cadvisor-0.25.0/info/v2/conversion_test.go000066400000000000000000000172151306035727200204600ustar00rootroot00000000000000// Copyright 2016 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package v2 import ( "reflect" "testing" "time" "github.com/google/cadvisor/info/v1" "github.com/stretchr/testify/assert" ) var ( timestamp = time.Date(1987, time.August, 10, 0, 0, 0, 0, time.UTC) labels = map[string]string{"foo": "bar"} ) func TestContanierSpecFromV1(t *testing.T) { v1Spec := v1.ContainerSpec{ CreationTime: timestamp, Labels: labels, HasCpu: true, Cpu: v1.CpuSpec{ Limit: 2048, MaxLimit: 4096, Mask: "cpu_mask", }, HasMemory: true, Memory: v1.MemorySpec{ Limit: 2048, Reservation: 1024, SwapLimit: 8192, }, HasNetwork: true, HasFilesystem: true, HasDiskIo: true, HasCustomMetrics: true, CustomMetrics: []v1.MetricSpec{{ Name: "foo", Type: v1.MetricGauge, Format: v1.IntType, Units: "bars", }}, Image: "gcr.io/kubernetes/kubernetes:v1", } aliases := []string{"baz", "oof"} namespace := "foo_bar_baz" expectedV2Spec := ContainerSpec{ CreationTime: timestamp, Labels: labels, HasCpu: true, Cpu: CpuSpec{ Limit: 2048, MaxLimit: 4096, Mask: "cpu_mask", }, HasMemory: true, Memory: MemorySpec{ Limit: 2048, Reservation: 1024, SwapLimit: 8192, }, HasNetwork: true, HasFilesystem: true, HasDiskIo: true, HasCustomMetrics: true, CustomMetrics: []v1.MetricSpec{{ Name: "foo", Type: v1.MetricGauge, Format: v1.IntType, Units: "bars", }}, Image: "gcr.io/kubernetes/kubernetes:v1", Aliases: aliases, Namespace: namespace, } v2Spec := ContainerSpecFromV1(&v1Spec, aliases, namespace) if !reflect.DeepEqual(v2Spec, expectedV2Spec) { t.Errorf("Converted spec differs from expectation!\nExpected: %+v\n Got: %+v\n", expectedV2Spec, v2Spec) } } func TestContainerStatsFromV1(t *testing.T) { v1Spec := v1.ContainerSpec{ CreationTime: timestamp, Labels: labels, HasCpu: true, Cpu: v1.CpuSpec{ Limit: 2048, MaxLimit: 4096, Mask: "cpu_mask", }, HasMemory: true, Memory: v1.MemorySpec{ Limit: 2048, Reservation: 1024, SwapLimit: 8192, }, HasNetwork: true, HasFilesystem: true, HasDiskIo: true, HasCustomMetrics: true, CustomMetrics: []v1.MetricSpec{{ Name: "foo", Type: v1.MetricGauge, Format: v1.IntType, Units: "bars", }}, Image: "gcr.io/kubernetes/kubernetes:v1", } v1Stats := v1.ContainerStats{ Timestamp: timestamp, Memory: v1.MemoryStats{ Usage: 1, Cache: 2, RSS: 3, WorkingSet: 4, Failcnt: 5, ContainerData: v1.MemoryStatsMemoryData{ Pgfault: 1, Pgmajfault: 2, }, HierarchicalData: v1.MemoryStatsMemoryData{ Pgfault: 10, Pgmajfault: 20, }, }, Network: v1.NetworkStats{ InterfaceStats: v1.InterfaceStats{ Name: "", RxBytes: 1, RxPackets: 2, RxErrors: 3, RxDropped: 4, TxBytes: 5, TxPackets: 6, TxErrors: 7, TxDropped: 8, }, Interfaces: []v1.InterfaceStats{{ Name: "eth0", RxBytes: 10, RxPackets: 20, RxErrors: 30, RxDropped: 40, TxBytes: 50, TxPackets: 60, TxErrors: 70, TxDropped: 80, }}, }, Filesystem: []v1.FsStats{{ Device: "dev0", Limit: 500, Usage: 100, BaseUsage: 50, Available: 300, InodesFree: 100, }}, } expectedV2Stats := ContainerStats{ Timestamp: timestamp, Cpu: &v1Stats.Cpu, DiskIo: &v1Stats.DiskIo, Memory: &v1Stats.Memory, Network: &NetworkStats{ Interfaces: v1Stats.Network.Interfaces, }, Filesystem: &FilesystemStats{ TotalUsageBytes: &v1Stats.Filesystem[0].Usage, BaseUsageBytes: &v1Stats.Filesystem[0].BaseUsage, InodeUsage: &v1Stats.Filesystem[0].Inodes, }, } v2Stats := ContainerStatsFromV1("test", &v1Spec, []*v1.ContainerStats{&v1Stats}) actualV2Stats := *v2Stats[0] if !reflect.DeepEqual(expectedV2Stats, actualV2Stats) { t.Errorf("Converted stats differs from expectation!\nExpected: %+v\n Got: %+v\n", expectedV2Stats, actualV2Stats) } } func TestInstCpuStats(t *testing.T) { tests := []struct { last *v1.ContainerStats cur *v1.ContainerStats want *CpuInstStats }{ // Last is missing { nil, &v1.ContainerStats{}, nil, }, // Goes back in time { &v1.ContainerStats{ Timestamp: time.Unix(100, 0).Add(time.Second), }, &v1.ContainerStats{ Timestamp: time.Unix(100, 0), }, nil, }, // Zero time delta { &v1.ContainerStats{ Timestamp: time.Unix(100, 0), }, &v1.ContainerStats{ Timestamp: time.Unix(100, 0), }, nil, }, // Unexpectedly small time delta { &v1.ContainerStats{ Timestamp: time.Unix(100, 0), }, &v1.ContainerStats{ Timestamp: time.Unix(100, 0).Add(30 * time.Millisecond), }, nil, }, // Different number of cpus { &v1.ContainerStats{ Timestamp: time.Unix(100, 0), Cpu: v1.CpuStats{ Usage: v1.CpuUsage{ PerCpu: []uint64{100, 200}, }, }, }, &v1.ContainerStats{ Timestamp: time.Unix(100, 0).Add(time.Second), Cpu: v1.CpuStats{ Usage: v1.CpuUsage{ PerCpu: []uint64{100, 200, 300}, }, }, }, nil, }, // Stat numbers decrease { &v1.ContainerStats{ Timestamp: time.Unix(100, 0), Cpu: v1.CpuStats{ Usage: v1.CpuUsage{ Total: 300, PerCpu: []uint64{100, 200}, User: 250, System: 50, }, }, }, &v1.ContainerStats{ Timestamp: time.Unix(100, 0).Add(time.Second), Cpu: v1.CpuStats{ Usage: v1.CpuUsage{ Total: 200, PerCpu: []uint64{100, 100}, User: 150, System: 50, }, }, }, nil, }, // One second elapsed { &v1.ContainerStats{ Timestamp: time.Unix(100, 0), Cpu: v1.CpuStats{ Usage: v1.CpuUsage{ Total: 300, PerCpu: []uint64{100, 200}, User: 250, System: 50, }, }, }, &v1.ContainerStats{ Timestamp: time.Unix(100, 0).Add(time.Second), Cpu: v1.CpuStats{ Usage: v1.CpuUsage{ Total: 500, PerCpu: []uint64{200, 300}, User: 400, System: 100, }, }, }, &CpuInstStats{ Usage: CpuInstUsage{ Total: 200, PerCpu: []uint64{100, 100}, User: 150, System: 50, }, }, }, // Two seconds elapsed { &v1.ContainerStats{ Timestamp: time.Unix(100, 0), Cpu: v1.CpuStats{ Usage: v1.CpuUsage{ Total: 300, PerCpu: []uint64{100, 200}, User: 250, System: 50, }, }, }, &v1.ContainerStats{ Timestamp: time.Unix(100, 0).Add(2 * time.Second), Cpu: v1.CpuStats{ Usage: v1.CpuUsage{ Total: 500, PerCpu: []uint64{200, 300}, User: 400, System: 100, }, }, }, &CpuInstStats{ Usage: CpuInstUsage{ Total: 100, PerCpu: []uint64{50, 50}, User: 75, System: 25, }, }, }, } for _, c := range tests { got, err := InstCpuStats(c.last, c.cur) if err != nil { if c.want == nil { continue } t.Errorf("Unexpected error: %v", err) } assert.Equal(t, c.want, got) } } cadvisor-0.25.0/info/v2/machine.go000066400000000000000000000147511306035727200166420ustar00rootroot00000000000000// Copyright 2015 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 v2 import ( // TODO(rjnagal): Move structs from v1. "time" "github.com/google/cadvisor/info/v1" ) type Attributes 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"` // The number of cores in this machine. NumCores int `json:"num_cores"` // Maximum clock speed for the cores, in KHz. CpuFrequency uint64 `json:"cpu_frequency_khz"` // The amount of memory (in bytes) in this machine MemoryCapacity uint64 `json:"memory_capacity"` // The machine id MachineID string `json:"machine_id"` // The system uuid SystemUUID string `json:"system_uuid"` // Filesystems on this machine. Filesystems []v1.FsInfo `json:"filesystems"` // Disk map DiskMap map[string]v1.DiskInfo `json:"disk_map"` // Network devices NetworkDevices []v1.NetInfo `json:"network_devices"` // Machine Topology // Describes cpu/memory layout and hierarchy. Topology []v1.Node `json:"topology"` // Cloud provider the machine belongs to CloudProvider v1.CloudProvider `json:"cloud_provider"` // Type of cloud instance (e.g. GCE standard) the machine is. InstanceType v1.InstanceType `json:"instance_type"` } func GetAttributes(mi *v1.MachineInfo, vi *v1.VersionInfo) Attributes { return Attributes{ KernelVersion: vi.KernelVersion, ContainerOsVersion: vi.ContainerOsVersion, DockerVersion: vi.DockerVersion, CadvisorVersion: vi.CadvisorVersion, NumCores: mi.NumCores, CpuFrequency: mi.CpuFrequency, MemoryCapacity: mi.MemoryCapacity, MachineID: mi.MachineID, SystemUUID: mi.SystemUUID, Filesystems: mi.Filesystems, DiskMap: mi.DiskMap, NetworkDevices: mi.NetworkDevices, Topology: mi.Topology, CloudProvider: mi.CloudProvider, InstanceType: mi.InstanceType, } } // MachineStats contains usage statistics for the entire machine. type MachineStats struct { // The time of this stat point. Timestamp time.Time `json:"timestamp"` // In nanoseconds (aggregated) Cpu *v1.CpuStats `json:"cpu,omitempty"` // In nanocores per second (instantaneous) CpuInst *CpuInstStats `json:"cpu_inst,omitempty"` // Memory statistics Memory *v1.MemoryStats `json:"memory,omitempty"` // Network statistics Network *NetworkStats `json:"network,omitempty"` // Filesystem statistics Filesystem []MachineFsStats `json:"filesystem,omitempty"` // Task load statistics Load *v1.LoadStats `json:"load_stats,omitempty"` } // MachineFsStats contains per filesystem capacity and usage information. type MachineFsStats struct { // The block device name associated with the filesystem. Device string `json:"device"` // Type of filesystem. Type string `json:"type"` // Number of bytes that can be consumed on this filesystem. Capacity *uint64 `json:"capacity,omitempty"` // Number of bytes that is currently consumed on this filesystem. Usage *uint64 `json:"usage,omitempty"` // Number of bytes available for non-root user on this filesystem. Available *uint64 `json:"available,omitempty"` // Number of inodes that are available on this filesystem. InodesFree *uint64 `json:"inodes_free,omitempty"` // DiskStats for this device. DiskStats `json:"inline"` } // DiskStats contains per partition usage information. // This information is only available at the machine level. type DiskStats struct { // Number of reads completed // This is the total number of reads completed successfully. ReadsCompleted *uint64 `json:"reads_completed,omitempty"` // Number of reads merged // Reads and writes which are adjacent to each other may be merged for // efficiency. Thus two 4K reads may become one 8K read before it is // ultimately handed to the disk, and so it will be counted (and queued) // as only one I/O. This field lets you know how often this was done. ReadsMerged *uint64 `json:"reads_merged,omitempty"` // Number of sectors read // This is the total number of sectors read successfully. SectorsRead *uint64 `json:"sectors_read,omitempty"` // Time spent reading // This is the total number of milliseconds spent by all reads (as // measured from __make_request() to end_that_request_last()). ReadDuration *time.Duration `json:"read_duration,omitempty"` // Number of writes completed // This is the total number of writes completed successfully. WritesCompleted *uint64 `json:"writes_completed,omitempty"` // Number of writes merged // See the description of reads merged. WritesMerged *uint64 `json:"writes_merged,omitempty"` // Number of sectors written // This is the total number of sectors written successfully. SectorsWritten *uint64 `json:"sectors_written,omitempty"` // Time spent writing // This is the total number of milliseconds spent by all writes (as // measured from __make_request() to end_that_request_last()). WriteDuration *time.Duration `json:"write_duration,omitempty"` // Number of I/Os currently in progress // The only field that should go to zero. Incremented as requests are // given to appropriate struct request_queue and decremented as they finish. IoInProgress *uint64 `json:"io_in_progress,omitempty"` // Time spent doing I/Os // This field increases so long as field 9 is nonzero. IoDuration *time.Duration `json:"io_duration,omitempty"` // weighted time spent doing I/Os // This field is incremented at each I/O start, I/O completion, I/O // merge, or read of these stats by the number of I/Os in progress // (field 9) times the number of milliseconds spent doing I/O since the // last update of this field. This can provide an easy measure of both // I/O completion time and the backlog that may be accumulating. WeightedIoDuration *time.Duration `json:"weighted_io_duration,omitempty"` } cadvisor-0.25.0/integration/000077500000000000000000000000001306035727200157405ustar00rootroot00000000000000cadvisor-0.25.0/integration/framework/000077500000000000000000000000001306035727200177355ustar00rootroot00000000000000cadvisor-0.25.0/integration/framework/framework.go000066400000000000000000000244261306035727200222710ustar00rootroot00000000000000// 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 framework import ( "bytes" "flag" "fmt" "os/exec" "strings" "testing" "time" "github.com/golang/glog" "github.com/google/cadvisor/client" "github.com/google/cadvisor/client/v2" ) var host = flag.String("host", "localhost", "Address of the host being tested") var port = flag.Int("port", 8080, "Port of the application on the host being tested") var sshOptions = flag.String("ssh-options", "", "Command line options for ssh") // Integration test framework. type Framework interface { // Clean the framework state. Cleanup() // The testing.T used by the framework and the current test. T() *testing.T // Returns the hostname being tested. Hostname() HostnameInfo // Returns the Docker actions for the test framework. Docker() DockerActions // Returns the shell actions for the test framework. Shell() ShellActions // Returns the cAdvisor actions for the test framework. Cadvisor() CadvisorActions } // Instantiates a Framework. Cleanup *must* be called. Class is thread-compatible. // All framework actions report fatal errors on the t specified at creation time. // // Typical use: // // func TestFoo(t *testing.T) { // fm := framework.New(t) // defer fm.Cleanup() // ... actual test ... // } func New(t *testing.T) Framework { // All integration tests are large. if testing.Short() { t.Skip("Skipping framework test in short mode") } // Try to see if non-localhost hosts are GCE instances. fm := &realFramework{ hostname: HostnameInfo{ Host: *host, Port: *port, }, t: t, cleanups: make([]func(), 0), } fm.shellActions = shellActions{ fm: fm, } fm.dockerActions = dockerActions{ fm: fm, } return fm } const ( Aufs string = "aufs" Overlay string = "overlay" DeviceMapper string = "devicemapper" Unknown string = "" ) type DockerActions interface { // Run the no-op pause Docker container and return its ID. RunPause() string // Run the specified command in a Docker busybox container and return its ID. RunBusybox(cmd ...string) string // Runs a Docker container in the background. Uses the specified DockerRunArgs and command. // Returns the ID of the new container. // // e.g.: // Run(DockerRunArgs{Image: "busybox"}, "ping", "www.google.com") // -> docker run busybox ping www.google.com Run(args DockerRunArgs, cmd ...string) string RunStress(args DockerRunArgs, cmd ...string) string Version() []string StorageDriver() string } type ShellActions interface { // Runs a specified command and arguments. Returns the stdout and stderr. Run(cmd string, args ...string) (string, string) RunStress(cmd string, args ...string) (string, string) } type CadvisorActions interface { // Returns a cAdvisor client to the machine being tested. Client() *client.Client ClientV2() *v2.Client } type realFramework struct { hostname HostnameInfo t *testing.T cadvisorClient *client.Client cadvisorClientV2 *v2.Client shellActions shellActions dockerActions dockerActions // Cleanup functions to call on Cleanup() cleanups []func() } type shellActions struct { fm *realFramework } type dockerActions struct { fm *realFramework } type HostnameInfo struct { Host string Port int } // Returns: http://:/ func (self HostnameInfo) FullHostname() string { return fmt.Sprintf("http://%s:%d/", self.Host, self.Port) } func (self *realFramework) T() *testing.T { return self.t } func (self *realFramework) Hostname() HostnameInfo { return self.hostname } func (self *realFramework) Shell() ShellActions { return self.shellActions } func (self *realFramework) Docker() DockerActions { return self.dockerActions } func (self *realFramework) Cadvisor() CadvisorActions { return self } // Call all cleanup functions. func (self *realFramework) Cleanup() { for _, cleanupFunc := range self.cleanups { cleanupFunc() } } // Gets a client to the cAdvisor being tested. func (self *realFramework) Client() *client.Client { if self.cadvisorClient == nil { cadvisorClient, err := client.NewClient(self.Hostname().FullHostname()) if err != nil { self.t.Fatalf("Failed to instantiate the cAdvisor client: %v", err) } self.cadvisorClient = cadvisorClient } return self.cadvisorClient } // Gets a v2 client to the cAdvisor being tested. func (self *realFramework) ClientV2() *v2.Client { if self.cadvisorClientV2 == nil { cadvisorClientV2, err := v2.NewClient(self.Hostname().FullHostname()) if err != nil { self.t.Fatalf("Failed to instantiate the cAdvisor client: %v", err) } self.cadvisorClientV2 = cadvisorClientV2 } return self.cadvisorClientV2 } func (self dockerActions) RunPause() string { return self.Run(DockerRunArgs{ Image: "kubernetes/pause", }) } // Run the specified command in a Docker busybox container. func (self dockerActions) RunBusybox(cmd ...string) string { return self.Run(DockerRunArgs{ Image: "busybox", }, cmd...) } type DockerRunArgs struct { // Image to use. Image string // Arguments to the Docker CLI. Args []string InnerArgs []string } // TODO(vmarmol): Use the Docker remote API. // TODO(vmarmol): Refactor a set of "RunCommand" actions. // Runs a Docker container in the background. Uses the specified DockerRunArgs and command. // // e.g.: // RunDockerContainer(DockerRunArgs{Image: "busybox"}, "ping", "www.google.com") // -> docker run busybox ping www.google.com func (self dockerActions) Run(args DockerRunArgs, cmd ...string) string { dockerCommand := append(append([]string{"docker", "run", "-d"}, args.Args...), args.Image) dockerCommand = append(dockerCommand, cmd...) output, _ := self.fm.Shell().Run("sudo", dockerCommand...) // The last line is the container ID. elements := strings.Fields(output) containerId := elements[len(elements)-1] self.fm.cleanups = append(self.fm.cleanups, func() { self.fm.Shell().Run("sudo", "docker", "rm", "-f", containerId) }) return containerId } func (self dockerActions) Version() []string { dockerCommand := []string{"docker", "version", "-f", "'{{.Server.Version}}'"} output, _ := self.fm.Shell().Run("sudo", dockerCommand...) output = strings.TrimSpace(output) ret := strings.Split(output, ".") if len(ret) != 3 { self.fm.T().Fatalf("invalid version %v", output) } return ret } func (self dockerActions) StorageDriver() string { dockerCommand := []string{"docker", "info"} output, _ := self.fm.Shell().Run("sudo", dockerCommand...) if len(output) < 1 { self.fm.T().Fatalf("failed to find docker storage driver - %v", output) } for _, line := range strings.Split(output, "\n") { line = strings.TrimSpace(line) if strings.HasPrefix(line, "Storage Driver: ") { idx := strings.LastIndex(line, ": ") + 2 driver := line[idx:] switch driver { case Aufs: return Aufs case Overlay: return Overlay case DeviceMapper: return DeviceMapper default: return Unknown } } } self.fm.T().Fatalf("failed to find docker storage driver from info - %v", output) return Unknown } func (self dockerActions) RunStress(args DockerRunArgs, cmd ...string) string { dockerCommand := append(append(append(append([]string{"docker", "run", "-m=4M", "-d", "-t", "-i"}, args.Args...), args.Image), args.InnerArgs...), cmd...) output, _ := self.fm.Shell().RunStress("sudo", dockerCommand...) // The last line is the container ID. if len(output) < 1 { self.fm.T().Fatalf("need 1 arguments in output %v to get the name but have %v", output, len(output)) } elements := strings.Fields(output) containerId := elements[len(elements)-1] self.fm.cleanups = append(self.fm.cleanups, func() { self.fm.Shell().Run("sudo", "docker", "rm", "-f", containerId) }) return containerId } func (self shellActions) wrapSsh(command string, args ...string) *exec.Cmd { cmd := []string{self.fm.Hostname().Host, "--", "sh", "-c", "\"", command} cmd = append(cmd, args...) cmd = append(cmd, "\"") if *sshOptions != "" { cmd = append(strings.Split(*sshOptions, " "), cmd...) } return exec.Command("ssh", cmd...) } func (self shellActions) Run(command string, args ...string) (string, string) { var cmd *exec.Cmd if self.fm.Hostname().Host == "localhost" { // Just run locally. cmd = exec.Command(command, args...) } else { // We must SSH to the remote machine and run the command. cmd = self.wrapSsh(command, args...) } var stdout bytes.Buffer var stderr bytes.Buffer cmd.Stdout = &stdout cmd.Stderr = &stderr glog.Infof("About to run - %v", cmd.Args) err := cmd.Run() if err != nil { self.fm.T().Fatalf("Failed to run %q %v in %q with error: %q. Stdout: %q, Stderr: %s", command, args, self.fm.Hostname().Host, err, stdout.String(), stderr.String()) return "", "" } return stdout.String(), stderr.String() } func (self shellActions) RunStress(command string, args ...string) (string, string) { var cmd *exec.Cmd if self.fm.Hostname().Host == "localhost" { // Just run locally. cmd = exec.Command(command, args...) } else { // We must SSH to the remote machine and run the command. cmd = self.wrapSsh(command, args...) } var stdout bytes.Buffer var stderr bytes.Buffer cmd.Stdout = &stdout cmd.Stderr = &stderr err := cmd.Run() if err != nil { self.fm.T().Logf("Ran %q %v in %q and received error: %q. Stdout: %q, Stderr: %s", command, args, self.fm.Hostname().Host, err, stdout.String(), stderr.String()) return stdout.String(), stderr.String() } return stdout.String(), stderr.String() } // Runs retryFunc until no error is returned. After dur time the last error is returned. // Note that the function does not timeout the execution of retryFunc when the limit is reached. func RetryForDuration(retryFunc func() error, dur time.Duration) error { waitUntil := time.Now().Add(dur) var err error for time.Now().Before(waitUntil) { err = retryFunc() if err == nil { return nil } } return err } cadvisor-0.25.0/integration/runner/000077500000000000000000000000001306035727200172515ustar00rootroot00000000000000cadvisor-0.25.0/integration/runner/retrywhitelist.txt000066400000000000000000000001311306035727200231070ustar00rootroot00000000000000Network tx and rx bytes should not be equal Network tx and rx packets should not be equalcadvisor-0.25.0/integration/runner/run.sh000077500000000000000000000020631306035727200204150ustar00rootroot00000000000000#!/bin/bash # Copyright 2015 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. set -e set -x # Check usage. if [ $# == 0 ]; then echo "USAGE: run.sh " exit 1 fi # Don't run on trivial changes. if ! git diff --name-only origin/master | grep -c -E "*.go|*.sh" &> /dev/null; then echo "This PR does not touch files that require integration testing. Skipping integration tests." exit 0 fi # Build the runner. go build github.com/google/cadvisor/integration/runner # Run it. HOSTS=$@ ./runner --logtostderr $HOSTS cadvisor-0.25.0/integration/runner/runner.go000066400000000000000000000205211306035727200211110ustar00rootroot00000000000000// Copyright 2015 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 ( "bufio" "bytes" "encoding/json" "errors" "flag" "fmt" "io/ioutil" "net/http" "os" "os/exec" "path" "regexp" "strconv" "strings" "sync" "time" "github.com/golang/glog" cadvisorApi "github.com/google/cadvisor/info/v2" ) // must be able to ssh into hosts without password // go run ./integration/runner/runner.go --logtostderr --v 2 --ssh-config <.ssh/config file> const ( cadvisorBinary = "cadvisor" testTimeout = 15 * time.Minute ) var cadvisorTimeout = flag.Duration("cadvisor_timeout", 15*time.Second, "Time to wait for cAdvisor to come up on the remote host") var port = flag.Int("port", 8080, "Port in which to start cAdvisor in the remote host") var testRetryCount = flag.Int("test-retry-count", 3, "Number of times to retry failed tests before failing.") var testRetryWhitelist = flag.String("test-retry-whitelist", "", "Path to newline separated list of regexexp for test failures that should be retried. If empty, no tests are retried.") var sshOptions = flag.String("ssh-options", "", "Commandline options passed to ssh.") var retryRegex *regexp.Regexp func getAttributes(ipAddress, portStr string) (*cadvisorApi.Attributes, error) { // Get host attributes and log attributes if the tests fail. var attributes cadvisorApi.Attributes resp, err := http.Get(fmt.Sprintf("http://%s:%s/api/v2.1/attributes", ipAddress, portStr)) if err != nil { return nil, fmt.Errorf("failed to get attributes - %v", err) } if resp.StatusCode != http.StatusOK { return nil, fmt.Errorf("failed to get attributes. Status code - %v", resp.StatusCode) } defer resp.Body.Close() body, err := ioutil.ReadAll(resp.Body) if err != nil { return nil, fmt.Errorf("unable to read attributes response body - %v", err) } if err := json.Unmarshal(body, &attributes); err != nil { return nil, fmt.Errorf("failed to unmarshal attributes - %v", err) } return &attributes, nil } func RunCommand(cmd string, args ...string) error { output, err := exec.Command(cmd, args...).CombinedOutput() if err != nil { return fmt.Errorf("command %q %q failed with error: %v and output: %s", cmd, args, err, output) } return nil } func RunSshCommand(cmd string, args ...string) error { if *sshOptions != "" { args = append(strings.Split(*sshOptions, " "), args...) } return RunCommand(cmd, args...) } func PushAndRunTests(host, testDir string) (result error) { // Push binary. glog.Infof("Pushing cAdvisor binary to %q...", host) err := RunSshCommand("ssh", host, "--", "mkdir", "-p", testDir) if err != nil { return fmt.Errorf("failed to make remote testing directory: %v", err) } defer func() { err = RunSshCommand("ssh", host, "--", "rm", "-rf", testDir) if err != nil { glog.Errorf("Failed to cleanup test directory: %v", err) } }() err = RunSshCommand("scp", "-r", cadvisorBinary, fmt.Sprintf("%s:%s", host, testDir)) if err != nil { return fmt.Errorf("failed to copy binary: %v", err) } // Start cAdvisor. glog.Infof("Running cAdvisor on %q...", host) portStr := strconv.Itoa(*port) errChan := make(chan error) go func() { err = RunSshCommand("ssh", host, "--", fmt.Sprintf("sudo GORACE='halt_on_error=1' %s --port %s --logtostderr --docker_env_metadata_whitelist=TEST_VAR &> %s/log.txt", path.Join(testDir, cadvisorBinary), portStr, testDir)) if err != nil { errChan <- fmt.Errorf("error running cAdvisor: %v", err) } }() defer func() { err = RunSshCommand("ssh", host, "--", "sudo", "pkill", cadvisorBinary) if err != nil { glog.Errorf("Failed to cleanup: %v", err) } }() defer func() { if result != nil { // Copy logs from the host err := RunSshCommand("scp", fmt.Sprintf("%s:%s/log.txt", host, testDir), "./") if err != nil { result = fmt.Errorf("error fetching logs: %v for %v", err, result) return } defer os.Remove("./log.txt") logs, err := ioutil.ReadFile("./log.txt") if err != nil { result = fmt.Errorf("error reading local log file: %v for %v", err, result) return } glog.Errorf("----------------------\nLogs from Host: %q\n%v\n", host, string(logs)) // Get attributes for debugging purposes. attributes, err := getAttributes(host, portStr) if err != nil { glog.Errorf("Failed to read host attributes: %v", err) } result = fmt.Errorf("error on host %s: %v\n%+v", host, result, attributes) } }() // Wait for cAdvisor to come up. endTime := time.Now().Add(*cadvisorTimeout) done := false for endTime.After(time.Now()) && !done { select { case err := <-errChan: // Quit early if there was an error. return err case <-time.After(500 * time.Millisecond): // Stop waiting when cAdvisor is healthy.. resp, err := http.Get(fmt.Sprintf("http://%s:%s/healthz", host, portStr)) if err == nil && resp.StatusCode == http.StatusOK { done = true break } } } if !done { return fmt.Errorf("timed out waiting for cAdvisor to come up at host %q", host) } // Run the tests in a retry loop. glog.Infof("Running integration tests targeting %q...", host) for i := 0; i <= *testRetryCount; i++ { // Check if this is a retry if i > 0 { time.Sleep(time.Second * 15) // Wait 15 seconds before retrying glog.Warningf("Retrying (%d of %d) tests on host %s due to error %v", i, *testRetryCount, host, err) } // Run the command err = RunCommand("go", "test", "--timeout", testTimeout.String(), "github.com/google/cadvisor/integration/tests/...", "--host", host, "--port", portStr, "--ssh-options", *sshOptions) if err == nil { // On success, break out of retry loop break } // Only retry on test failures caused by these known flaky failure conditions if retryRegex == nil || !retryRegex.Match([]byte(err.Error())) { glog.Warningf("Skipping retry for tests on host %s because error is not whitelisted", host) break } } return err } func Run() error { start := time.Now() defer func() { glog.Infof("Execution time %v", time.Since(start)) }() defer glog.Flush() hosts := flag.Args() testDir := fmt.Sprintf("/tmp/cadvisor-%d", os.Getpid()) glog.Infof("Running integration tests on host(s) %q", strings.Join(hosts, ",")) // Build cAdvisor. glog.Infof("Building cAdvisor...") err := RunCommand("build/build.sh") if err != nil { return err } defer func() { err := RunCommand("rm", cadvisorBinary) if err != nil { glog.Error(err) } }() // Run test on all hosts in parallel. var wg sync.WaitGroup allErrors := make([]error, 0) var allErrorsLock sync.Mutex for _, host := range hosts { wg.Add(1) go func(host string) { defer wg.Done() err := PushAndRunTests(host, testDir) if err != nil { func() { allErrorsLock.Lock() defer allErrorsLock.Unlock() allErrors = append(allErrors, err) }() } }(host) } wg.Wait() if len(allErrors) != 0 { var buffer bytes.Buffer for i, err := range allErrors { buffer.WriteString(fmt.Sprintf("Error %d: ", i)) buffer.WriteString(err.Error()) buffer.WriteString("\n") } return errors.New(buffer.String()) } glog.Infof("All tests pass!") return nil } // initRetryWhitelist initializes the whitelist of test failures that can be retried. func initRetryWhitelist() { if *testRetryWhitelist == "" { return } file, err := os.Open(*testRetryWhitelist) if err != nil { glog.Fatal(err) } defer file.Close() retryStrings := []string{} scanner := bufio.NewScanner(file) for scanner.Scan() { text := scanner.Text() if text != "" { retryStrings = append(retryStrings, text) } } if err := scanner.Err(); err != nil { glog.Fatal(err) } retryRegex = regexp.MustCompile(strings.Join(retryStrings, "|")) } func main() { flag.Parse() // Check usage. if len(flag.Args()) == 0 { glog.Fatalf("USAGE: runner ") } initRetryWhitelist() // Run the tests. err := Run() if err != nil { glog.Fatal(err) } } cadvisor-0.25.0/integration/tests/000077500000000000000000000000001306035727200171025ustar00rootroot00000000000000cadvisor-0.25.0/integration/tests/TODO.md000066400000000000000000000001711306035727200201700ustar00rootroot00000000000000Tests to Write: - UI comes up -- / -> /containers -- /containers -- /docker - API tests -- /containers -- /subcontainers cadvisor-0.25.0/integration/tests/api/000077500000000000000000000000001306035727200176535ustar00rootroot00000000000000cadvisor-0.25.0/integration/tests/api/attributes_test.go000066400000000000000000000020711306035727200234270ustar00rootroot00000000000000// Copyright 2015 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 api import ( "testing" "github.com/google/cadvisor/integration/framework" "github.com/stretchr/testify/assert" ) func TestAttributeInformationIsReturned(t *testing.T) { fm := framework.New(t) defer fm.Cleanup() attributes, err := fm.Cadvisor().ClientV2().Attributes() if err != nil { t.Fatal(err) } vp := `\d+\.\d+\.\d+` assert.True(t, assert.Regexp(t, vp, attributes.DockerVersion), "Expected %s to match %s", attributes.DockerVersion, vp) } cadvisor-0.25.0/integration/tests/api/docker_test.go000066400000000000000000000305501306035727200225130ustar00rootroot00000000000000// 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 api import ( "fmt" "os" "strconv" "testing" "time" info "github.com/google/cadvisor/info/v1" "github.com/google/cadvisor/info/v2" "github.com/google/cadvisor/integration/framework" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // Sanity check the container by: // - Checking that the specified alias is a valid one for this container. // - Verifying that stats are not empty. func sanityCheck(alias string, containerInfo info.ContainerInfo, t *testing.T) { assert.Contains(t, containerInfo.Aliases, alias, "Alias %q should be in list of aliases %v", alias, containerInfo.Aliases) assert.NotEmpty(t, containerInfo.Stats, "Expected container to have stats") } // Sanity check the container by: // - Checking that the specified alias is a valid one for this container. // - Verifying that stats are not empty. func sanityCheckV2(alias string, info v2.ContainerInfo, t *testing.T) { assert.Contains(t, info.Spec.Aliases, alias, "Alias %q should be in list of aliases %v", alias, info.Spec.Aliases) assert.NotEmpty(t, info.Stats, "Expected container to have stats") } // Waits up to 5s for a container with the specified alias to appear. func waitForContainer(alias string, fm framework.Framework) { err := framework.RetryForDuration(func() error { ret, err := fm.Cadvisor().Client().DockerContainer(alias, &info.ContainerInfoRequest{ NumStats: 1, }) if err != nil { return err } if len(ret.Stats) != 1 { return fmt.Errorf("no stats returned for container %q", alias) } return nil }, 5*time.Second) require.NoError(fm.T(), err, "Timed out waiting for container %q to be available in cAdvisor: %v", alias, err) } func getDockerMinorVersion(fm framework.Framework) int { val, err := strconv.Atoi(fm.Docker().Version()[1]) assert.Nil(fm.T(), err) return val } // A Docker container in /docker/ func TestDockerContainerById(t *testing.T) { fm := framework.New(t) defer fm.Cleanup() containerId := fm.Docker().RunPause() // Wait for the container to show up. waitForContainer(containerId, fm) request := &info.ContainerInfoRequest{ NumStats: 1, } containerInfo, err := fm.Cadvisor().Client().DockerContainer(containerId, request) require.NoError(t, err) sanityCheck(containerId, containerInfo, t) } // A Docker container in /docker/ func TestDockerContainerByName(t *testing.T) { fm := framework.New(t) defer fm.Cleanup() containerName := fmt.Sprintf("test-docker-container-by-name-%d", os.Getpid()) fm.Docker().Run(framework.DockerRunArgs{ Image: "kubernetes/pause", Args: []string{"--name", containerName}, }) // Wait for the container to show up. waitForContainer(containerName, fm) request := &info.ContainerInfoRequest{ NumStats: 1, } containerInfo, err := fm.Cadvisor().Client().DockerContainer(containerName, request) require.NoError(t, err) sanityCheck(containerName, containerInfo, t) } // Find the first container with the specified alias in containers. func findContainer(alias string, containers []info.ContainerInfo, t *testing.T) info.ContainerInfo { for _, cont := range containers { for _, a := range cont.Aliases { if alias == a { return cont } } } t.Fatalf("Failed to find container %q in %+v", alias, containers) return info.ContainerInfo{} } // All Docker containers through /docker func TestGetAllDockerContainers(t *testing.T) { fm := framework.New(t) defer fm.Cleanup() // Wait for the containers to show up. containerId1 := fm.Docker().RunPause() containerId2 := fm.Docker().RunPause() waitForContainer(containerId1, fm) waitForContainer(containerId2, fm) request := &info.ContainerInfoRequest{ NumStats: 1, } containersInfo, err := fm.Cadvisor().Client().AllDockerContainers(request) require.NoError(t, err) if len(containersInfo) < 2 { t.Fatalf("At least 2 Docker containers should exist, received %d: %+v", len(containersInfo), containersInfo) } sanityCheck(containerId1, findContainer(containerId1, containersInfo, t), t) sanityCheck(containerId2, findContainer(containerId2, containersInfo, t), t) } // Check expected properties of a Docker container. func TestBasicDockerContainer(t *testing.T) { fm := framework.New(t) defer fm.Cleanup() containerName := fmt.Sprintf("test-basic-docker-container-%d", os.Getpid()) containerId := fm.Docker().Run(framework.DockerRunArgs{ Image: "kubernetes/pause", Args: []string{ "--name", containerName, }, }) // Wait for the container to show up. waitForContainer(containerId, fm) request := &info.ContainerInfoRequest{ NumStats: 1, } containerInfo, err := fm.Cadvisor().Client().DockerContainer(containerId, request) require.NoError(t, err) // Check that the contianer is known by both its name and ID. sanityCheck(containerId, containerInfo, t) sanityCheck(containerName, containerInfo, t) assert.Empty(t, containerInfo.Subcontainers, "Should not have subcontainers") assert.Len(t, containerInfo.Stats, 1, "Should have exactly one stat") } // TODO(vmarmol): Handle if CPU or memory is not isolated on this system. // Check the ContainerSpec. func TestDockerContainerSpec(t *testing.T) { fm := framework.New(t) defer fm.Cleanup() var ( cpuShares = uint64(2048) cpuMask = "0" memoryLimit = uint64(1 << 30) // 1GB image = "kubernetes/pause" env = map[string]string{"test_var": "FOO"} labels = map[string]string{"bar": "baz"} ) cpusetArg := "--cpuset" if getDockerMinorVersion(fm) >= 10 { cpusetArg = "--cpuset-cpus" } containerId := fm.Docker().Run(framework.DockerRunArgs{ Image: image, Args: []string{ "--cpu-shares", strconv.FormatUint(cpuShares, 10), cpusetArg, cpuMask, "--memory", strconv.FormatUint(memoryLimit, 10), "--env", "TEST_VAR=FOO", "--label", "bar=baz", }, }) // Wait for the container to show up. waitForContainer(containerId, fm) request := &info.ContainerInfoRequest{ NumStats: 1, } containerInfo, err := fm.Cadvisor().Client().DockerContainer(containerId, request) require.NoError(t, err) sanityCheck(containerId, containerInfo, t) assert := assert.New(t) assert.True(containerInfo.Spec.HasCpu, "CPU should be isolated") assert.Equal(cpuShares, containerInfo.Spec.Cpu.Limit, "Container should have %d shares, has %d", cpuShares, containerInfo.Spec.Cpu.Limit) assert.Equal(cpuMask, containerInfo.Spec.Cpu.Mask, "Cpu mask should be %q, but is %q", cpuMask, containerInfo.Spec.Cpu.Mask) assert.True(containerInfo.Spec.HasMemory, "Memory should be isolated") assert.Equal(memoryLimit, containerInfo.Spec.Memory.Limit, "Container should have memory limit of %d, has %d", memoryLimit, containerInfo.Spec.Memory.Limit) assert.True(containerInfo.Spec.HasNetwork, "Network should be isolated") assert.True(containerInfo.Spec.HasDiskIo, "Blkio should be isolated") assert.Equal(image, containerInfo.Spec.Image, "Spec should include container image") assert.Equal(env, containerInfo.Spec.Envs, "Spec should include environment variables") assert.Equal(labels, containerInfo.Spec.Labels, "Spec should include labels") } // Check the CPU ContainerStats. func TestDockerContainerCpuStats(t *testing.T) { fm := framework.New(t) defer fm.Cleanup() // Wait for the container to show up. containerId := fm.Docker().RunBusybox("ping", "www.google.com") waitForContainer(containerId, fm) request := &info.ContainerInfoRequest{ NumStats: 1, } containerInfo, err := fm.Cadvisor().Client().DockerContainer(containerId, request) if err != nil { t.Fatal(err) } sanityCheck(containerId, containerInfo, t) // Checks for CpuStats. checkCpuStats(t, containerInfo.Stats[0].Cpu) } // Check the memory ContainerStats. func TestDockerContainerMemoryStats(t *testing.T) { fm := framework.New(t) defer fm.Cleanup() // Wait for the container to show up. containerId := fm.Docker().RunBusybox("ping", "www.google.com") waitForContainer(containerId, fm) request := &info.ContainerInfoRequest{ NumStats: 1, } containerInfo, err := fm.Cadvisor().Client().DockerContainer(containerId, request) require.NoError(t, err) sanityCheck(containerId, containerInfo, t) // Checks for MemoryStats. checkMemoryStats(t, containerInfo.Stats[0].Memory) } // Check the network ContainerStats. func TestDockerContainerNetworkStats(t *testing.T) { fm := framework.New(t) defer fm.Cleanup() // Wait for the container to show up. containerId := fm.Docker().RunBusybox("watch", "-n1", "wget", "http://www.google.com/") waitForContainer(containerId, fm) time.Sleep(10 * time.Second) request := &info.ContainerInfoRequest{ NumStats: 1, } containerInfo, err := fm.Cadvisor().Client().DockerContainer(containerId, request) require.NoError(t, err) sanityCheck(containerId, containerInfo, t) // Checks for NetworkStats. stat := containerInfo.Stats[0] assert := assert.New(t) assert.NotEqual(0, stat.Network.TxBytes, "Network tx bytes should not be zero") assert.NotEqual(0, stat.Network.TxPackets, "Network tx packets should not be zero") assert.NotEqual(0, stat.Network.RxBytes, "Network rx bytes should not be zero") assert.NotEqual(0, stat.Network.RxPackets, "Network rx packets should not be zero") assert.NotEqual(stat.Network.RxBytes, stat.Network.TxBytes, "Network tx and rx bytes should not be equal") assert.NotEqual(stat.Network.RxPackets, stat.Network.TxPackets, "Network tx and rx packets should not be equal") } func TestDockerFilesystemStats(t *testing.T) { fm := framework.New(t) defer fm.Cleanup() storageDriver := fm.Docker().StorageDriver() if storageDriver == framework.DeviceMapper { // Filesystem stats not supported with devicemapper, yet return } const ( ddUsage = uint64(1 << 3) // 1 KB sleepDuration = 10 * time.Second ) // Wait for the container to show up. // FIXME: Tests should be bundled and run on the remote host instead of being run over ssh. // Escaping bash over ssh is ugly. // Once github issue 1130 is fixed, this logic can be removed. dockerCmd := fmt.Sprintf("dd if=/dev/zero of=/file count=2 bs=%d & ping google.com", ddUsage) if fm.Hostname().Host != "localhost" { dockerCmd = fmt.Sprintf("'%s'", dockerCmd) } containerId := fm.Docker().RunBusybox("/bin/sh", "-c", dockerCmd) waitForContainer(containerId, fm) request := &v2.RequestOptions{ IdType: v2.TypeDocker, Count: 1, } needsBaseUsageCheck := false switch storageDriver { case framework.Aufs, framework.Overlay, framework.DeviceMapper: needsBaseUsageCheck = true } pass := false // We need to wait for the `dd` operation to complete. for i := 0; i < 10; i++ { containerInfo, err := fm.Cadvisor().ClientV2().Stats(containerId, request) if err != nil { t.Logf("%v stats unavailable - %v", time.Now().String(), err) t.Logf("retrying after %s...", sleepDuration.String()) time.Sleep(sleepDuration) continue } require.Equal(t, len(containerInfo), 1) var info v2.ContainerInfo // There is only one container in containerInfo. Since it is a map with unknown key, // use the value blindly. for _, cInfo := range containerInfo { info = cInfo } sanityCheckV2(containerId, info, t) require.NotNil(t, info.Stats[0], "got info: %+v", info) require.NotNil(t, info.Stats[0].Filesystem, "got info: %+v", info) require.NotNil(t, info.Stats[0].Filesystem.TotalUsageBytes, "got info: %+v", info.Stats[0].Filesystem) if *info.Stats[0].Filesystem.TotalUsageBytes >= ddUsage { if !needsBaseUsageCheck { pass = true break } require.NotNil(t, info.Stats[0].Filesystem.BaseUsageBytes) if *info.Stats[0].Filesystem.BaseUsageBytes >= ddUsage { pass = true break } } t.Logf("expected total usage %d bytes to be greater than %d bytes", *info.Stats[0].Filesystem.TotalUsageBytes, ddUsage) if needsBaseUsageCheck { t.Logf("expected base %d bytes to be greater than %d bytes", *info.Stats[0].Filesystem.BaseUsageBytes, ddUsage) } t.Logf("retrying after %s...", sleepDuration.String()) time.Sleep(sleepDuration) } if !pass { t.Fail() } } cadvisor-0.25.0/integration/tests/api/event_test.go000066400000000000000000000043521306035727200223660ustar00rootroot00000000000000// Copyright 2015 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 api import ( "strings" "testing" "time" info "github.com/google/cadvisor/info/v1" "github.com/google/cadvisor/integration/framework" "github.com/stretchr/testify/require" ) func TestStreamingEventInformationIsReturned(t *testing.T) { // TODO(vmarmol): De-flake and re-enable. t.Skip() fm := framework.New(t) defer fm.Cleanup() // Watch for container deletions einfo := make(chan *info.Event) go func() { err := fm.Cadvisor().Client().EventStreamingInfo("?deletion_events=true&stream=true&subcontainers=true", einfo) require.NoError(t, err) }() // Create a short-lived container. containerId := fm.Docker().RunBusybox("sleep", "2") // Wait for the deletion event. timeout := time.After(30 * time.Second) done := false for !done { select { case ev := <-einfo: if ev.EventType == info.EventContainerDeletion { if strings.Contains(ev.ContainerName, containerId) { done = true } } case <-timeout: t.Errorf( "timeout happened before destruction event was detected for container %q", containerId) done = true } } // We should have already received a creation event. waitForStaticEvent(containerId, "?creation_events=true&subcontainers=true", t, fm, info.EventContainerCreation) } func waitForStaticEvent(containerId string, urlRequest string, t *testing.T, fm framework.Framework, typeEvent info.EventType) { einfo, err := fm.Cadvisor().Client().EventStaticInfo(urlRequest) require.NoError(t, err) found := false for _, ev := range einfo { if ev.EventType == typeEvent { if strings.Contains(ev.ContainerName, containerId) { found = true break } } } require.True(t, found) } cadvisor-0.25.0/integration/tests/api/machine_test.go000066400000000000000000000034701306035727200226510ustar00rootroot00000000000000// 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 api import ( "testing" "github.com/google/cadvisor/integration/framework" ) func TestMachineInformationIsReturned(t *testing.T) { fm := framework.New(t) defer fm.Cleanup() machineInfo, err := fm.Cadvisor().Client().MachineInfo() if err != nil { t.Fatal(err) } // Check for "sane" values. Note these can change with time. if machineInfo.NumCores <= 0 || machineInfo.NumCores >= 1000000 { t.Errorf("Machine info has unexpected number of cores: %v", machineInfo.NumCores) } if machineInfo.MemoryCapacity <= 0 || machineInfo.MemoryCapacity >= (1<<50 /* 1PB */) { t.Errorf("Machine info has unexpected amount of memory: %v", machineInfo.MemoryCapacity) } if len(machineInfo.Filesystems) == 0 { t.Errorf("Expected to have some filesystems, found none") } for _, fs := range machineInfo.Filesystems { if fs.Device == "" { t.Errorf("Expected a non-empty device name in: %+v", fs) } if fs.Capacity < 0 || fs.Capacity >= (1<<60 /* 1 EB*/) { t.Errorf("Unexpected capacity in device %q: %v", fs.Device, fs.Capacity) } if fs.Type == "" { t.Errorf("Filesystem type is not set") } else if fs.Type == "vfs" && fs.Inodes == 0 { t.Errorf("Inodes not available for device %q", fs.Device) } } } cadvisor-0.25.0/integration/tests/api/machinestats_test.go000066400000000000000000000031751306035727200237320ustar00rootroot00000000000000// Copyright 2015 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 api import ( "testing" "time" "github.com/google/cadvisor/integration/framework" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) func TestMachineStatsIsReturned(t *testing.T) { fm := framework.New(t) defer fm.Cleanup() machineStats, err := fm.Cadvisor().ClientV2().MachineStats() if err != nil { t.Fatal(err) } as := assert.New(t) for _, stat := range machineStats { as.NotEqual(stat.Timestamp, time.Time{}) as.True(stat.Cpu.Usage.Total > 0) as.True(len(stat.Cpu.Usage.PerCpu) > 0) if stat.CpuInst != nil { as.True(stat.CpuInst.Usage.Total > 0) } as.True(stat.Memory.Usage > 0) for _, nStat := range stat.Network.Interfaces { as.NotEqual(nStat.Name, "") as.NotEqual(nStat.RxBytes, 0) } for _, fsStat := range stat.Filesystem { as.NotEqual(fsStat.Device, "") as.NotNil(fsStat.Capacity) as.NotNil(fsStat.Usage) as.NotNil(fsStat.ReadsCompleted) require.NotEmpty(t, fsStat.Type) if fsStat.Type == "vfs" { as.NotEmpty(fsStat.InodesFree) } } } } cadvisor-0.25.0/integration/tests/api/test_utils.go000066400000000000000000000042711306035727200224050ustar00rootroot00000000000000// 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 api import ( "testing" "time" info "github.com/google/cadvisor/info/v1" "github.com/stretchr/testify/assert" ) // Checks that expected and actual are within delta of each other. func inDelta(t *testing.T, expected, actual, delta uint64, description string) { var diff uint64 if expected > actual { diff = expected - actual } else { diff = actual - expected } if diff > delta { t.Errorf("%s (%d and %d) are not within %d of each other", description, expected, actual, delta) } } // Checks that CPU stats are valid. func checkCpuStats(t *testing.T, stat info.CpuStats) { assert := assert.New(t) assert.NotEqual(0, stat.Usage.Total, "Total CPU usage should not be zero") assert.NotEmpty(stat.Usage.PerCpu, "Per-core usage should not be empty") totalUsage := uint64(0) for _, usage := range stat.Usage.PerCpu { totalUsage += usage } inDelta(t, stat.Usage.Total, totalUsage, uint64((5 * time.Millisecond).Nanoseconds()), "Per-core CPU usage") inDelta(t, stat.Usage.Total, stat.Usage.User+stat.Usage.System, uint64((500 * time.Millisecond).Nanoseconds()), "User + system CPU usage") // TODO(rjnagal): Add verification for cpu load. } func checkMemoryStats(t *testing.T, stat info.MemoryStats) { assert := assert.New(t) assert.NotEqual(0, stat.Usage, "Memory usage should not be zero") assert.NotEqual(0, stat.WorkingSet, "Memory working set should not be zero") if stat.WorkingSet > stat.Usage { t.Errorf("Memory working set (%d) should be at most equal to memory usage (%d)", stat.WorkingSet, stat.Usage) } // TODO(vmarmol): Add checks for ContainerData and HierarchicalData } cadvisor-0.25.0/integration/tests/healthz/000077500000000000000000000000001306035727200205415ustar00rootroot00000000000000cadvisor-0.25.0/integration/tests/healthz/healthz_test.go000066400000000000000000000021741306035727200235720ustar00rootroot00000000000000// 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 healthz import ( "io/ioutil" "net/http" "testing" "github.com/google/cadvisor/integration/framework" ) func TestHealthzOk(t *testing.T) { fm := framework.New(t) defer fm.Cleanup() // Ensure that /heathz returns "ok" resp, err := http.Get(fm.Hostname().FullHostname() + "healthz") if err != nil { t.Fatal(err) } defer resp.Body.Close() body, err := ioutil.ReadAll(resp.Body) if err != nil { t.Fatal(err) } if string(body) != "ok" { t.Fatalf("cAdvisor returned unexpected healthz status of %q", body) } } cadvisor-0.25.0/integration/tests/healthz/test_utils.go000066400000000000000000000011621306035727200232670ustar00rootroot00000000000000// 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 healthz cadvisor-0.25.0/logo.png000066400000000000000000002241671306035727200150770ustar00rootroot00000000000000‰PNG  IHDRµbÙ w(>IDATxÚìÝ÷_\סïýç߹綧ܸ;.q‰;‰§Ú‰sâä8‰SÓlKôÞ« z Ì Cï†245:Dï3ø‡„C$Y†){¯½÷çýúþà›cÃfí5{½î—ÍZÿק¨ÅÎ΃@˶¶¶àôþ/† míÆ2ÓêÚC@kæænffåŒ]¹ÊP§G?PÝÝÝ€ o_SyÅÚú:@ ænÞÌÊÎýä¼w|âF8úq€ªÔÕ7|rÞÛo_ÿŠÊª Æ€ZÍÏÏçäæŸóò9zî 0&À™ÐTekkËÇ/à¨*rÄñÏ•UÕ›››Œ 5¹}ûN^~áq3îHdTÌáá!#œ ý8@mÊLåÇ…ÑÉ–œwɨÀíÛ·ïkÆbîîap€³¢¨Íò½{ç½}ïkŽhÉ(Ýç5㎇0DÀYÑT(7/ÿÁþˆ–€B=¢?Jm]=£8~ B“Ÿ×"·ä•Uëë댑ÍÏA3ßÚÚc8~ Nq ‰®ÈZrSyÅ*½ñܼy+'7ÿÑÍøQ ‹Š.À9ôãu2w÷|a©to_c™éÞÊ ƒ@33³™Y9§|‚9255Í Ρ¨ÓÞÞž_@Ðé &/¿½ayy™¡ —ÉÉ©ôŒ¬Ó?¸‰OdܧÑTËXf:SÍäÈyoßâ’ÒÅ¥%F€”ÆÇ'RÓÒÏúÈr¤ËÜÍèN£¨ÖÍ›·œ(›ŽZò‚¢ùùÛŒ!O»rõbrªs+o_ÿÆpý8@Íâ.8×:9rÎË';'ofv–aàv‡‡‡Ö¡aWžQŽ\ædNÀ5ôã5kïèt¥{:Ê¥´Œ7ÆLna·Û-}ýÑ1q®?x4.¢¨Ùæ榗Ÿë%”#.&Ž]aH8íàà ËÜå–‡RXDÔáá!£ ¸‚~ r¹yn©¢ŽŸØ?0h·ÛX§·³³ÓÜÒîÆÇQ]} ¸ˆ~ rcW®º±:JxDTg—yŸáðhëëëÕ5µ~Aî} óòY^^fxÑTÎn·…„¹½"w$08´¾¡qkk‹Að ÅÅŽÁÛ×ßÏŸ”Ô4Fpý8@ýŒe&OôSGñõ,¯¨\Y]eœ™›ËË/t<<÷äé2w3΀ëèÇê799å¹–ê(^>~Eº’ùùÛŒ6 eW®^»”–áéÎyoß Fpý8@ýCÂ"<ÝX%=#ëúõŒ9 )½–¾˜Øxiž3i™Œ9àôãM(¯¨”¦·:Jl|b_ÿ€ÍfcäuÛÚÚjhlòÐ!Ÿ—ž^ #¸ý8@ffg¥l¯ŽÞÔܲ½½Íø곸´d,3ùøHü`ñòñ㩸 ý8@+Â#¢¤¯Èð,3•/..r u˜˜˜ÌÉÍ÷èñ›Hfv·púq€VTVUËRf圗OVvîãÜ@¡,}ýq d|’8â¸îà.ôã­˜œš’·Õ:JLl¼¹»gŸ;(ÅÚúzm]}`p¨ìóÞ¾›››ÜÀ]èÇZa·Û‚BD¨Èq\IuMíÊê*÷ÙÜÜÍËÅ:/?AÉ)—¸)€Ñ4¤HW"HÉuü*h^~Áøø·ÊÁÁAÿÀàÅäT¡žŽ´´¶qw7¢hÈÐðˆhm×Q¢câÚ;:···¹G€¼–ïÝ«®©a+•‡faá.÷p#úq€†ìîOƒññ (ÑnÞ¼Å$vxx8våjVvîyo_a‘Q1Ü)À½èÇÚ’ž™%lùuœ “-}ýœá H`ss³¹¥5<2Zü'CEe÷ p/úq€¶tv™ÅoÁŽâl,3ñ:9à ‡‡‡W®^ËÍ+ùoJîËøgnF?Ж»wï*¥ ;NÂ…¤.s÷Îηpݽ{÷êêBÃ#•õðñ 888àöîE?Ðœ°ÅUäGíX‘®drrŠ;8Áf³Y‡†Ó3²Îyù(ñ ‘™ÍMÜŽ~ 9º’R%¶cljŠ‰kjn¹wï·R‡‡‡»»»[[[›››«kk+««÷VV–weeÅñÏŽÿem}Ýñrü ÛÛÛ{{{ŽÿÄñ2z²˜+3•…(úƒßÖÞÁ­ÜŽ~ 9ƒVE×dG9çå“’šÖÝÓ»½½Í==“ÃÃí­­Å¥¥¹¹›7nŒ ôôZZÛÚëê**«J Æ¢â으Դô¤‹)±ñ‰Q1!aA!Þ¾þ.¾z|ÞÛ×Ç/Àñ¥_02:6.á‚ã[\JËp|;Ç7u|kÇÔ74¶wtZúúGFÇ&&&oÝš_^^fw'8Æ­¡±É1Î*ø¼;2?›{ ¸ý8@s666ºÁÂCãåã—›W0<2ÊÞÄGö÷÷—–—§§gFFÇÌÝ=õ zcYn^~JjZtl|`pèyo_%ÞhÇe‡†ÇÆ'¦^JÏË/(3•765w÷ô:~Ì™™Ù{++6›»ï°½½í–ä”KªùŒ;Æ<~ Eq ‰jêÎŽâ\¢7\¿~Ãn·«þ,.-ݸ1Þké«ohÔ•”fdfÇÆ':A}wöô OLÊÎÉ3Ëš[Z­SSÓ+««ZØÚeww·`Ðñ³{ûú«ïÎóÜ<~ E•Uê.IK Æë7n¨ã…â©éé¾þú†Æ"]IrÊ¥àÐp5ý€4GF§¥g:&FsK«uhxîæMuìÌãø)úûÔZ‹Çbéã¹ xý8@‹FÇƴЊú_.Ö ìîî*â¾ÌÏß´5469®<1)Ù/ ˆvÛ£¿JIN¹¤+Õ7·´ŽŒŽÝ]\Tʬ®®v™»ÓÒ3½|ü´p§–––xnž@?Т­­-M½€ìåã—ž‘ÕÑÙ%TËf³Ùæço Z«kjsró#£cº3¸Ê¦Jl|bAaQ}CãðÈèâÒ’8{³8®dvv®®¾!>1IS7%84œ‡6à!ô㊉KÐfc,3ŒŽíììH<æ›››7nŒ·´¶ÇÆ'jäÍ_¥ÇÇ/ ébJ©ÁØÙežžžÙÛÛ“xÚ¬¬¬ôZú ‹‚B´y /óÄ<„~ Qzƒ‘=©.\¬¨¬ÛÜÜôÄ oll\¹z­¾¡1'7?4<’®YÓ&:6þr±®­½crrÊC[÷,//÷õ”è Q1ŒyGgOlÀCèÇeéë§w»ï½òËźŽÎ®©©i§_-ßßßwüçmí…Eá‘ÑŒªêsÎË':6¾¸¤´ËÜ=7wÓéíËWVWÇ®\mljÎÎÉ c`OÆ1°<±¡hÔÝ»wéÝ‘°ˆ¨Ì¬SyEGg×ÈèØÌÌ콕•½½½“»Q;þyssóöíÏNÔtü› .²e ›±¤^J¯®©»²¸´tß/Zìvûöö¶ãŸššnim+ÑRRÓ4»qÊiâíëo³ÙxbB?Ð.ÿÀ`Ú7ç:P_ÿ@o_MqJœÞÅ1UŽ& £áD’S/ñ¬<‡~ ]éY´o„‘S^Qɳðúq€vU×ÔÒ¾BDÎÀÀ ÏjÀsèÇÚ5<M!D´ÔÔÖñ|<~ u•U4q„ÑÒkéãù xý8@ëÚ;:iâ!¢åÆqžÏ€§Ñ´nxx„&Ž"Zîò|<~ u3³³4q„Ѳ»»Ëóð4úq€ÖÝ[Y¡‰#„¿΀èÇZ···GG*á‘Ñ<œ Ðð©_}!Dœ\¸˜Ì“ý8Ÿ†…GÒÇBÄIfvOf@ôã|—@G'…E<™ ÐðéÅäTú8Bˆ8)5y2 àÓôÌ,ú8Bˆ8©¨¬âÉ H€~€O³rréã!⤺¦–'3 úq>ÍÍ+ #„ˆ“ºúžÌ€èÇø´ ð2}!Dœ446ñd$@?À§yù…ôq„qRßÐÈ“ý8ŸæäæÓÇBÄIMmOf@ôã|š™CG'UÕ5<™ ÐðiJj}!DœŒe<™ Ðði\B"}!Dœód$@?À§¡á‘ôq„q’™•Ã“ý8@ë½|üèã!â$.ág@ôã­[__§Œ#„•€ ΀èÇZ7;;GG-»»»<ŸO£h]__?M!D´ÌÍÝäù xý8@몪khâ!¢¥¯€ç3àiôã­KMK§‰#„ˆ–2S9ÏgÀÓèÇšf·Û}ühâ!¢%>1‰G4àiôãM›žž¡†#„˜óÞ¾[[[<¥¢hZuM-5!DÌ ò”<Š~ iQ1qtp„1“›WÀSð(úq€vMNNQÀB„—ßúú:ÏjÀsèÇÚ•_PHG9õ <«Ï¡hÔüüís^>´o„‘ã¼½½Íðúq€F¥gfQ½BÄOEeOlÀCèÇZÔké£t#„("ç½}§§gxnž@?Ðœ¹¹›>~”n„¥$$,bum§7àvôãm™˜˜  ¡n#„(+Q1qwy†îE?Ðæ–ÖóÞ¾m„%Æ×?phx„'9àFôãMØÛÛËÍ+ _#„(=•UÕ‡‡‡<Õ· ¨ßâÒRL\µ!DIËÈÜÚÚâÙ¸Ž~ rW®^ó ¦P#„¨)‘Ñóó·yÂ.¢¨Yk[;ŽBÔºùÈè(ÏyÀôãu²ÙlºR= !DÅ9çåÓÔÜÂpý8@…¶¶¶R.¥ÑB´¢bÍfãÉ8~ 6ËËËQ1qTf„í$õRúöö6Ïà¬èǪ23;JYFÑZbbãï­¬° gB?Pѱ1¿j2Bˆ6~óÖ-ÖàôèÇ*ÑÓk9ïíKAFÑrü‚Æ'&X€S¢¨ASs‹‹0_ÿ€ˆ¨èĤ‹é™¹yù—‹ŠKõ½Áh,39b0–9þ¹¨X—_P˜™•”œBHšs^>A!a1qñÉ©—²rr /ëJSÞè˜êGsÞñϺR}á墜¼üÔ´ôøÄ a‘ŽÏ‰ÖÊñ# °.§A?P¼ŠÊ*µ¿˜”œR¬+©ohì˜\^^ÞÛÛ;tŠÍf[[[››imk3ËÒ32C©_‰8‰ˆŠÎÊÎ1•WttvŽŽŽÝ¼ukccÃn·;7çwvvî..Þ¸1Þk±ÔÔÖ^NHLRwo~ÞÛ·»§—ÕøBôã;<<,5Õ×m‡dçæÕ74Ž]YYYqº<“­­­‰ÉÉöŽÎb]ITL,-‘2q ‰c™¹»gvvvwwW‚ o³Ùî.. W×Ô¦gdúúªïuû¶ö– àÑèÇJe·Û/ëTSf…GF—”ê{-} wïJSˆ?ÚúúúÈÈheUuÒÅÚ[âöxùø]J˨«o¸~ýÆÎÎŽìÞf³Ý¼u«£³«àrQPH¨jƹ¡±‰Åxúq€"Ùíö¼üBT„é™mí wï lccc``ðrQq@Û——e0–ŽŽ‰Ð‰Çãeîæ͆Ʀ¤ä”s^>JóêšZ– àóДGé帷¯~AáÐа4ûH¸÷Û©©)Syû•“3%*:¶¶®~þöíC¥ÙÜÜì鵤gdž÷ö¡"Ô‡~ 0Ê-ÇÏ{ûææå[­CŠ«Åú‚íÄĤ±ÌLùKñ¶xMmÝ­ùùCåÛØØ0w÷¤¦¥+ô^8nËð úq€’æ(¯ŒŠini]__?TýýýÁAkZz]09ù« ¼ü‚«W¯Ùl6õÍù»‹‹UÕ5A!aŠ»/µuõ,"À}èÇJR¤+QPuÎË'/¿`||B„ó6%( +«ªý‚h‡µœ°µþ*è>Ã##)—Ò”uƒšš[XG€“èÇŠ¡7–)¥„òñ (3•/.-jÌÎÎN[{GXDM±ÖŸp¡¿ààà@ksþæÍ›—‹Š´;yGg« pŒ~  •UŠèž‚‚›š›·¶¶5Ìf³ Z­qñ‰´ÆZÈ¥´Œë×ohá$áÞ½{å•Þ¾þŠø»–^Kk p„~ -­mâ·N~A M;;;‡ø瞃ƒÖè˜8dµæbJêøøSýØêꪱÌäåã+þñ£cWXY€OéÇâëëë?çå#øn*5µugüï’÷÷„GFÓ&«)‰.^½zéýPË÷î•”êÅjMMO³¾ôã¡]¹zí¼·Ð/cëVWWém¿©¹Å×?fYù'p†[úú5¾›ÊiÌß¾–‘)ò­ô ¾sç« 4Ž~ ®[·æEnT“.¦ÌÌÎÒžÞúúzI©žŠY¡ñöõ«©­ÛÝÝe&ŸÞèèXdtŒ°÷4,"Êñ©d­–ѵºº!ì!œ½–>^¡uÎÜÜ\|Âêfe%#+{yy™ÙëÜO465yùø‰yg.\ÜÛÛcÅfÑD´»»—(fTPxy}}ÖÏMÍ-Þ¾~ôÎâ'08¤¿€I뢅……äÔKbÞâìœ<Dzî@›èÇÂ9<<ÌÊÎrç刱±+4}îrwq1õR:´È¹\T¼±±Á\u »ÝÞeîsϨʪj–hý8@8UÕ5öGù…[[[t|no [ZÛ¼||i¢Å;¼1ÈjbŠºÝÒòrRrŠ€w¼¯€ÕD?KÿÀ hµ‘_@O¯…^ÏsnÞ¼G%-NR.¥­¬¬03=Äf³ÕÖÕŸóòìüUÿ™ÙYÖ h ý8@ óóó>~‚^—t÷î]=OÛÝÝ-)ÕSLËžs^>MÍ6›9éiSÓÓ¡á‘¢m!µ±±ÁJM¡ˆb{{;"2Z¨¶HWRº··G‘'™^‹…C;e=Š3ôÆø8óP2i™BÍÔ´t»ÝÎzí ˆ"3;Gœ’ÈËÇÏÜÝC'Ë^+aQTÕÒçÂÅdöT‘e¯•êšZ¡fBEeë´ƒ~ „¦æ¡6˜›£¹“Ëææfº`/Õª>¥zÃþþ>sO.##£¾þm-5:6ƪ Èojjú¼·¯ ÅP|Â…ÕÕU ;Ù_ª-Õ¨­¥IKkSNþ¿œ¸u+$,\)²²²ÂÚ- ÈlkkKœCê2³²wvv¨ê!Ô_¨2Þ¾~CCÃÌ4A¬¬¬ÄÆ'27.&§²9´€~ ³ìœ1Áúõ¡Hjm}Ý/@æ-¤só ìv;¥›¢õôöÒzŸ2^>¾“ÌEÛÙÙ‰O¼ ÷É®q6›U *C?T¾Ü$]LÙÛÛ£nSšÚ:ºïÓd`pÙ¢«««¡áòÎ¥ú†FV1¨ ý8@:×¯ß·Ü Œ^__§hSÍÑ……—‹¨¿Ʀ&¦ŠjÌß¾í(ãtòöõ_^^f-ƒšÐ$b·Û£câdlvü¨ØT¶/³g½ ›¢b“De®^»&ï¤ÊÎÍc9ƒšÐ$ÒÖÞ!o­322J¹¦ÊM'‚BB©ÂL|â¶R¥Æ¦fy§Öµë×YÑ ôã)lnnÊ{,guM-µšZMLLž÷ö¡?™€ à¥åeæ†ZwÊÎÍ“qvEÇÆ;®u ê@?‚±Ì$c›“ž‘i³Ù¨ÕTLö¿N-W¯]cV¨ØöövTt¬Œ¬ËÜͺu xÜâ⢗Ÿ\=NphØÆÆ…šêåäåS‹¥¦¶Žù zóóó2>WƒBÂöööXÝ ôãËÍ+s«ÜkשҴ`ss384œrüBRòÁÁóA6Ñ.ãL«­«guƒ Ð7oÝRSf³ÙFGF ó >ùèãï~ç­§âñÿó%çòúk_ûýo—’œl6›777Õ4JûûûÑ1qÚ,dz²sTVþÎÎΚŒeAïüðGÏ<ù”ÓÞ‘7¾þúŸ?ü0'+{ppPe¿6´Zåšr>~¬tP4úq€¥gdÉUÜTUר¦¿=?_S]óÛ_àJ'þyyú‰'ùïgefNNL¨cÄ&&'µ¹³Šjþ2`mmmÈjûÆ믻}Â;òü³_þðÿY\T¬š½h²²säšx啬tP4úq€§Ìݼ)We³··§¾½VVVŠ/½ûãŸx¢4täßû~jrÊ͹›J(½Á¨µ~¼³«K•û‡ŒŽŒF„…¿ô‹ž˜ðO>öø¯ßÿeiIÉæƆҟ ¾þríB¾µµÅzå¢xJ^~\]á¸Z^…þ<=ÝÝ¿zÿ}µäO|é±ß~ðAC}ƒÝnWèøloo‡„…k§OJNQîÍ:ͬÌÌW^zÙCsþùg¿àçåÊåQg—Y®éWWßÀzå¢xÄÝ»wÏyùÈRÖéJµ¡¡¾á¯¿î¡ÆБ7¿ù­Ë……;;;Jœ¡¡a”ãŽÚüíÛZ˜ð«++Až›ðŽ|ð«_wvt*qpìv{bÒEYf`@PÈÞÞ«Š~àrmpáë°¶¶v¨›Ÿ|ô±Gï}õ«— •¸_MÊ¥4-ôãÆ2Ó¡–ôtw¿öÊ«óïýôßÍf³âFfzzZ®IØÑÙŪ…¢¸ßÖÖ–_€,5MSsó¡ö\.,|âKy´1üÆë¯×TW+kXnݺ¥úrÜ?0hssSk~qqñ½Ÿþ»G'¼#¿ùõãããʙ¢byŽ|ˆŠq|wÖ>(ý8Àýšš[déhÂ#£÷÷÷5©¡¾þé'žôtcø‹÷Þ»qㆂ†¥ToPw?Þ®ÌÍ@ܲÅüÿOOø§"<,LA¿XYYññó—e*Ž]¹ÂÚ%¢¸™Ýn ”¥ ± jXSc£§ß"wäé'žLºpA)Û­¬¯¯ûú¨µŠŽ=88Ðì„ßßßÿÝ¿ñô„w䯿ÞÖÚª”a©«oe6¦¥g²üA‰èÇn6:vE–v&.!Ñn·j[‰N'A]èÈÛ?ø¡R¶ž¨©­Sk?>08¨ñ ¿¹¹ùî;?–fÎ*â¬ÚíímÿÀ`YΉ]ZZb„âÐÜ,3;G–®ptt쇇~>¾ÒÔ…_~ú™Ë……âÈÖÖ–_@ úÊñ˜¸x›ÍÆ„¿uóæWžAš9ÿ½·Þº~íšþ”¤¹Y–9YU]à Å¡¸ÓÊÊÊyo_é{™Ä¤‹¼<~üöè[ßþŽ4u¡#ç>þDü—jëÕ× 3Ûÿqëê$›ðÏ=ólUe¥àâøH‡H?'ƒBÂl6ë ”…~àNMò¼·xõê5ZÂc=ÝÝ’Õ…Ž¼óÃݹ}‡'ØMHFüý樂ó1QÑ‚HKk›,3sdtŒuÊB?p§¨˜8ºB|ü·¤¬ _íkW¯^erÉ28he’Ÿ477÷ôOJ9çÿò§?‹ü—Žkó ’~fææ°BYèÇn3;;'KWØß?@?xŸ‰ñq)»BG^|îù>KŸ°²¶¶æå㧎r<,"òàà€I~??‰çü/Þ{occCØ©ª®‘~r:>eÛÛÛ¬†Púq€Û”™Ê¥¯cBÂ"è êÏ~(q]øÜ3Ïvuv ; ºR½:úñ¶ö¦÷ƒf¦§%žðŽ¼ûÎWWVÄÕÕU/Nƒèîée5„‚ÐÜãðð084\ú.¦¥µfð¡Z[Z¥¯ Ÿ}êéns·˜rûΔã~Aâˆ*—_þÇû²Tä¾E^¤+‘~Š¦¥g² BAèÇî155-}ãã翵µE-øPûûû¯¾ô²ôuáóÏ~yppPÌ1IÏÌRz?^^QÉÜþï%K]øò‹_™ššp@††‡•Þß¹s‡‰ýy–—d™ðŽüñ÷°ÙlŽIÂ…$égiO¯…5JA?p°ˆ(é[1KXq˜ŒerÕ…o~ó[ËËË¢ ÈÁÁAPH¨rËñä”KN³ÍÍMq.æßû¾\s>48DÀ»cîî‘~¢ffå°&B)èÇnpû¶ ;;ÇÄÆ ØFY­â\Ìää¤\]¡#¿xï=N­¬ªVn?néënW÷Û·…zo:ÀÏ_Æ9¯+.ííììøøH5<4$ڜו꥟®cW®²2BèÇnœzIúþemmM¨jáÎW¾òÒäÄ„PWõío}KƺБºÚZÑêÂĤ‹JìÇu%¥¢dpPÐ_þôg¡.©¹©IÞ ÿÆ×_íÑtc|\úéj0–±2BèÇ®ÚÝÝõòñ“¸|I½”.ZWøë_þêñÿó¥ÅÅE¡®êÝÿDÞºð¥^¼s[¬#%[ÛÚ”Ø_½vM¨alinvÜ_??¡®ªÏÒ'ï„w䣿þU¨1±ÙlÒo»ÃâE ¸êêµkÒw…]æn±vuÈùÇ®BUøYkÿþ/e¯ × Ô˜,ß»§¸r< (X¨ÍÜ———_}éeÇÍŠˆêæ^¹rEö ïHEy¹PÃb,3I?iWVVX!>úq€«¤?ððœ—Ïúúº8ÝÓÜÜÜsÏ<{Ô‹mmm øV»ìÑ—ê…–¤‹)ÊêÇKõ¡ðÜÇÝÙ¨H±úñ«W¯Š0á_ùÊKËËËâ ËÄĤô“¶¯¯Ÿõ⣸*á‚Ô»9§¦‰µ¹Ê¿úõq/&Úþ*?ýÉ»"Ô…/½ð¢P#ÓÖÞ®¬~üÚµëâŒ^{[Ûñ ðójÂ÷÷õ‰0áùä£Å»Ý&ñ¤-.)e}„øèÇ.ÙÛÛ;ïí+qíÒÚÖ&NñTW[{²›œœª.|ëÍo Rúxy‰3, *Ç}üü÷÷÷:Ç•|ç[oßÖ¿ýå/‚íŠÞ"È„wÄb±ˆ32Å%¥RoAË ñÑ\21)ßíß¾#Êy;;;ß|ý“XkK«8ØÁÁÁÓO<)HWøÄ—gpÂ#£”ÒgåäŠ3nÙYY'oë;?ü‘Pýx^n®8ýø;?zÛn· 22Ö¡!é§îææ&«$G?pIsK«Ä…Kh¸@ûgfdÞ׈åfçˆsy3ÓÓât…ŽüÇ{?gp Æ2¥ôã]f³ ƒ¶ººúâó/œ¼§Ï=ó¬8°Cp` PsÞTfdd¶¶¶ÎyùH88øúW_°.çЄ Iâ÷ãźA†ëRJêCoèo?ø@˜?˜¨pÂ÷;o 2>×oÜxö†„E°PBpôãçI8gx¤(ïÒ–ètŸW‡…‡†Šp…æ®.»BGþøû?rMåâ÷ãÝ=½"ŒÕîîîW_~åóN^]XXá"÷ÁoÄœó-ÍÍ‚üVOú-È9¢‚£8¯ËÜ-qÕRT¬¤Zýþ[ßý¼.ì忲½½-û~ü·Äì ŸøÒc³33"ÜDëÐøýøí;w„ø]‚±ì÷4#-]ö+œŸŸwL-1çü¯ù+Qþf"Qê¿™˜œšb­„ÈèÇΓþõ[swÓÀÀÀ£ë0Ùwdž™¶+t$!.^„û¸ºº*x9î,Èvö?ÿÙ{¸¡_}ù•y¯0<4TØ ÿÙï„fgE¸e¦r‰çpO¯…µ"£8/#3[âªåÖ­["tL¾Þ>®Ã^íkò¾Bþ…W(o¾öêWD¸•!a"÷ãYÙ"ŒÒÄøøÞÓü¼<¯páÎgŸzZä9ŸŸ Æïö%žÃ•U¬•ý8Àyá‘ÑRö,^>¾"”ª»»»/|ù¹/¬Ã.$&Êu…CV«ÈEáQ:;:E¨ ³srEîÇ«kjE%ÇdþÂúâó/,-.Éu…ýõo‚Oøo¾þ†·òÎ;Ïᬜ\ÖJˆŒ~à$»Ý~ÞÛWÊž%!1I„‚©±¡ñ4uØÓO<91>.ýåííí½ó£·ÅïÇý}}E¸›uõ "÷ãÖ¡!FéÛßúÖiîé'},Ëåu´·‹?á²Ze¿•6›ÍÛ×_Ê9—Àr ‘Ñœ´²²"õ᜺ºÂsrÊ:ì‡ßÿô›2GED*¢+|é…Eøk€¡¡a‘ûñ;ÎyåÊ•ÓßV£Á õÎ* ¯¾ô²"æ|tT”èôõd¹„ÈèÇNššž–¸+lniáíË—_üÊé1¯sç¥<_±¶¦FEáQúûe¿¡·%ßnâô9ï-ĆBéii§¿§_~ú™±ÑQ)7;ú÷~®” ÿ½·Þ¡/*ÖI<“···Y1!,úq€“¬Ö!‰K–ÑÑ1Ù«%ëà™·öŽŽ‘æÚÌfóÓO<© ~üB‚ü'îïïŸóò³Ž‰¡N=kýêK/ÏLOKpaýó_4á¹uó¦ü;D55K<“o߾Ê aÑœÔÑÙ%uÉ"À^—RR(Åâãâ<ýyWgçsÏ<«¬®ð§?yW„þ7<2JÌ~<+'WöÁÙÚÚrâ—.o|ýõÉÉIOï³îã•5á1èõòÿ’Oò_mŽO°bBXôã'ÕÔÖI\²ìííÉ^-ýîƒß8׋ùùøzîú++*”õæøñ¦ÒïÏþ ´ŒL1ûqSy…ìƒÓÓÝíÜÍ}å+/ zèªÖ××þ$ÊÇs@ö{:wó¦Ä3yÐ:ÄŠ aÑœTj0JÙ°…„ÊÞ+ÙíöŸ{ÞéjìÝw~<77çÞKÚÙÙ  RbQx‹Å"ûm-)Õ‹Ù·µw(ô&ŽòÔãOäde»ý/'ÆFGßüæ·:áßzóÛ²ßÓ ‰grGg+&„E?pR^~¡” Kâ…‹²÷JSSS.¶cÏ?ûåÜœwºØmîþîwÞRn9îHnvŽì·µ¾¡QÌ~|hxXöÁùÓþ§‹·ø×ïÿrrbÂ-³½½}!!A‰*qœ'¾ôØÆƆì¿çóöõ“r&×Õ7°bBXôã'¥gfIÙ°ääæÉÞÖÕÖº¥#ûÁw¿W[Sk³Ùœ¾’+ccþðOŠnÆâãå%ÿ"½½böãÓ33²ηÞø†ëwù©ÇŸ ¹uë–Ó—±»»[ZRòÆ×_WÁœý¶FFÅH9“+*«X1!,úq€“.&§JÙ°è FÙK¥‹’Ü»ÓBVfæÂYÝÞÞ®ª¬üͯ?PAKx”w~ô¶ì·ul슘ýøÒÒ’¼#³¹±ñÄ—s×½~êñ'Îr®«³óL?13=œtñë_}M5s^W\,ÿ£LÚ§w©ÞÀŠ aÑœ— eÃR[W/{©ôÉG{b¿…ŸþäÝ„¸ø–æ–Ù™™«ÃÅÅEKoonvÎ~÷»çžyV5-áñ†3²ßÖ™ÙY1ûqÙ/½råŠ'núW_~åÜÇŸèKõ£#£›l6âø8>ÍMMÑQQoÿà‡*›ðŽ8~.Ùç|n^¾”3¹ °ˆ¢8)2:VkgþìÝŸzº;{ú‰'_}éåoë[o}û;_ûêWÕWˆ?˜{÷îÉ{[ï.. XŽ{ùøÊ>á%˜¯|å¥7¿ñÍ|ïûo½ùí×^yUÑÛ‹Ÿ&ùÓŸµv&mn^>+&„E?pRxD”” K¯¥OöRéµW^U}[-}FGFå½­öãA!¡²Oø¼Ü\æ§Ûóã·åßS¨¢²JÊÉœ•“ËŠ aÑœ!eÃ2<2"{©ôäcÓî¹=ímmòÞÖýý}ûñÈèÙ'|B\<óÓíyýµ¯É~g›¤œÌ™Ù¬˜ý8ÀIA!aR6,W¯]“·QZ]]¥ÚóD*ÊËe¯ ÏyùˆÖÇ%$Ê>,þÌO·çÙ§ž–ý涵K9™Ó22Y1!,úq€“$~|brRÞFivf†jÏÉÏË“½.ôõ­OJN‘}Xþúç¿0?=‘íímyïl—ÙÌûãÀúq€“Â#£¥lXfffäm”nܸA¯ç‰d¦gÈ^…ˆÖ§\J“}Xþð»ß1?=‘Õ•yïlOo/ûGèÇNŠŠŽ•²a™›“·Q¥×óDR’“e/‚ƒBBEëÇ/¥Éÿkƒ~õkæ§'r÷î]yﬥ¯OÊÉœ›WÀŠ aÑœ— eÃróæMy¥!«•^Ϲ(ÿFÛÁ¡a¢õã陲Ëû¿øæ§'2??/ïíëï—r2^fÅ„°èÇNJLJæýqÂûã*~ü׿üó“÷Ç]®¤”¢8)-#SSû_¿~^ÏÉHKgÿqö×TVäßÜ"åd.¯¨dÅ„°èÇNÊË/”²a™˜œ”·Qš™¡×óDòóòd/‚}ýEëÇ/&§Ê>,ùÓŸ™ŸžÈÖÖ–¼w¶ËÜ-åd®«o`Å„°èÇN*)ÕKÙ°\»v]ÞFiee…^Ï)7™d/‚Ï{ûˆÖÇ'\ÿµz?æ§ÛóÌ“OÉ~g[ÛÚ¥œÌmí¬˜ý8ÀI•UÕR6,##£ò6Jv»ýÉǧÝs{ÚZ[å½³¢•ãŽDEÇÊÞ¢ÆÇÅ1?Ýž¯õ5ÙïlCc“”“ÙÒ×ÏŠ aÑœ$ñˆ–¾>ÙK¥¯¾ü ížÛ322"ïmÝØØ° “}Âçæä0?Ýžw~ø#Ùï¬Ä¿Ý¼vý:+&„E?pÒà Uʆ¥½£CöRé§?y—vÏíYZZ’÷¶... Ø{ùøÊÿ–q}=óÓíùó‡Ê~gKõ)'óüümVL‹~उ‰I)–ÚºzÙK¥þú7Ú=÷æ¹gž•ý¶ÎÎÎ Ø;²»»+ïÈŒŽ2EÝž¨ˆHùÿ2 ¿@Ê™¼±±ÁŠ aÑœtWÚ·nõ£ì¥Ò…„Ú=÷æíüPöÛ:v劘ýøÒò²¼#³¾¾Îu{Š._–}Î'§\’ð/!üß‘¢8éàààœ—d%KN^¾ì¥RMu5íž{ãuî¼ì·µ§×"f?>33#ûà¼ñõ×™¥îMŸEþ£"£c$›Æ‘ѱ,—ý8Ày¡á‘’•,‰Ie/•&ÆÇi÷Ü›¬ÌLÙok}C£˜ýø°Ü'—:üñ÷`–º7«««òÞS»Ýîãç/Ù4ÎÈÊf­„ÈèÇÎKMK—¬d “½+´ÙlÏ?ûe >7¦ÛÜ­µ³ Ïr&m§üq\¼È,ucÞüÆ7e¿§›››RNã2S9k%DF?p^‰´Åâþþ¾ìÕÒ¿ú5Ÿ»òÔãOlmmÉ~OÓ3³ÄìÇË+*eœ®ÎN&ªã}ÞKö{zóÖ-‰ÍÃZ ‘Ñœ×ÖÞ!eÏrgaAþ×i“xÖmùÉÛï "*ZÌ~<;7Oþw76ž|ìq檻R¢ÓÉ~O‡††¥œÆ×®_g­„ÈèÇλ~㆔=ËØØÙ«¥þ¾>:>w%.6VözpppÞÛGÌ~<&6^„ßüìÝŸ2WÝ•YÎ\mni‘r¯®­±VBdôãç­­¯KÙ³´¶µ‰P§¾øü Ô|nIoOì7ô΂˜å¸#^>¾6›Mö!JMNa®º%ßùÖ›"ü£XW"Ù a¡„àèÇ. •¬j).)¡]ú该és=/>÷üÁÁìwsxxDØ~Ü‘öeºº%aá"<Á“.J6SÓÒY%!8úq€KÒ3¤;Û0ñÂEÚ¥ÚšZš>uTèPßÐ(r?><<"Â(}ëo0c]O_Ÿì·Òf³ùøHyÆ,«$G?pIm]½dU‹·¯Ÿoooo?÷̳”}.¦µ¥U„æ7'/_ä~Üñùa”âbc™±.æë_}M„[¹p÷®”Øjb•„àèÇ.¹rõª”mËíÛ·Eè˜Î}ü }Ÿ+y套÷÷÷E¸•a‘"÷ãYÙ9"ŒÒÕ«W™´.&&*Z„[9hµJ9ïÝ»Ç* ÁÑ\²¹¹)eÛÒÓÛ+BÇÔÛÓCßçJ¢£¢D¸kkk"—㎇ØívÆêÝw~̼u%“““"ÜÇòŠJÉfoPHK$ÄG?pUdt¬d…‹NŒ#:ÞzóÛT~Îå‰/=&HW(øáœÿ8¢óî]ƪ´¤„©ëtþ㽟 òà’òpÎܼ|ÖGˆ~àªRƒQ²Â%*:Vš©° €ÖϹüöƒ¹‰R¾Këtz-Æj{{ûå¿Âìu.uµµ"ÜÄÝÝÝóÞ>’MÝŽÎ.ÖGˆ~à*«uHʺp}}]ºð¥^¤øs"]‚ôã’’ÅïÇu¥zQ†+1‘ÙëDÞüÆ7m6›wp||BÚã"î°>B|ôãWmllHÙ¹ŒŒŒ R&]¸@÷wÖ¼ó£·¹}—ÖWü~\œ¿™XZ\úòÓÏ0‡Ïš¢Ë—¹ƒMMnÊâE ¸AL\‚dµ‹±Ì$HÙ´¶¶ö•ç_ þ;SZš[¹}W®^¿?Êò½{‚ ZLT4søLyãë¯ïíí rûRRÓ$›´…E¬ŒPúq€TU×HV»„GF ãRJ* àéóÓŸ¼+ν+3•+¥ïîédÐîÝ»÷ü³_f&Ÿ>zaŽÞÞÞ–róñ¾þVF(ý8À &§¦¤¬ îÞ§rzýµ¯Qž2ý}}âôã‘Ñ1JéÇsòòÅ·´ÔKÌäSæßýÞÁÁ 7nxdD²{ÞÛwss“•Š@?p»Ý"YùÒÞÑ)N]XQ^Nxš|ô׿‰s×—–”RŽ;âë(Nͺ»»ûÍ×ß`>Ÿ&æ®.qæ|©Þ ÙŒ½˜œÊ²¥ ¸Çå¢bÉÊ—ô̬C‘üügïQ>:Ï?ûåùùyqnYGg—‚úqGnŒ‹3z õ Lé/ÌŸ?ü“8·Ìn·‡„EH6]›[ZY¡ôã÷•ø÷Åéž&'&žyò) ÁG¤@¤B$>¨Ð-1Ë„À?ø!³úyñùĹ_ÓÓÓRN×»‹‹¬‰P úq€{øúJxba¯Pu!u>"ïýôßív»87kuuUYå¸#Á¡6›Mœ1\XXøÊó/0·?/ºâb¡P¦ò Éæj|âD(ý8Àm.ë$«`Ò22…ªŸl6Û{?ýwjÁó—Ÿ›êfµwt*®wäúB cuUÓû¡ùÃï~'Ôúûæ*ál®<ý8ÀmÆ®\‘¬‚9çå³±±!T usîæ‹Ï=O9x_L‚m âp19U‰ýx©Þ ÚHzŸ÷b†ß—×^yuiiI¨Û419)åD]Z^f5„‚ÐÜÆf³‡JÖÂttv‰V6Ô×?ñ¥Ç¨ãëí#Ú=ZZZRb9îH@Pðþþ¾Pƒ¹µµõƒï~y~œ§¢·§G´9¯7%›¥“SY ¡,ôãw’r—Û¸øÄCñÄÅÆÒå'o¿³»»+Ú ª©­Sh?îÈà U´ñœžš~‘Èÿ™ì¬,Ñnã3(åÉ=½ÖA( ý8Àæç祬 EÛØúh#ò?þþ…¯¿öµ;·ïxw‚CÕۧ¦¥ ø;¡ö¶¶§‚9ï}ÞKÀ»Óké“l~úøìîî²BYèÇnŸxAË;2;loo¿ûÎ5~&çÕ«W¼5££cÊ-Dz¸¸(àÀk¼ÿÕûûÍ‘¤äÉ&gQ±ŽŠC?p3swduŒ¯ÀÎÎŽ€ÔÒâÒ[o~[›Eá³O=mîê:RVN®Òûñªê1Çöâ…$Í–ã?~ûíõõuoÊí;w¤œœ“SS¬€Púq€›íííùIxJg§˜uáíÛ·¿ùúZ+ Ÿ~âÉæ¦&1ïÈÝÅE¥—ã?¥3Äñs„£"#5XŽÿ­ïÞ»wOÌ;Rª7Hw DB"Ë”ˆ~à~RžÒe³ÙÄ,§nÎÝ|óßÔNQøÌ“O5Ô׊Ê`,SA?îH—Ù,ì G†GhªÿÁ÷¾/æŽ7ëëëÞ¾~’MËîž^Ö>(ý8Àýî..žóò‘¬—± [.ܹóÝï¼¥…¢ð¹gžíhoöFlnnzûú«£ŒŠöwBŸmx}á‚FÊñwßùñÊÊŠ°7¢®¾A²9鼿¿ÏÚ%¢xDfVŽdÕÌ…¤äC­¬¬üügï©»(|套E¾ Mê(Ç2<2"òhæ<ùØãêžó¿ûà7›››ÂÞ‚½½½€ )·ÅgÕƒBÑ<¢ˆ[ +.VÁ^+ýõokkkâöÎÎŽ”» å²ØAÑèÇ444,e]8::v¨&cÙË/~E‰-á“=ºµµ¥ˆqÞÜÜô Rk?o³Ùq#¦§¦ßÿù/ÚŒ¿úÒË••Jy¶465Kùòø;wXé hôãÏŠO”¬¬‰Š‰üм“–—>ùèce…?úþ±¿Ä±2S¹ZËñ£˜»{t;JKJ”õk¡'¾ô˜ŸïêÊŠRFxmmÍ×?P²éWPx™5JG?ð¬áá)ë¶ööCEèïÿÉÛï(âZ]q±RÞV>rçÎóÞ>êîǃC···tSVWWÃCCqPíÏÞýéð𰲞'ºR½dsï¼·ï; ¬qP:úq€Ç%\¸(Yeã´±±q¨4µ5µ?øî÷Äl ¿òü i©—6777ªé™Yê.ÇRQY¥¸[355õÉG?ùØãbÎyLJ±¾®Nq£:w󦔯HWÂê xÜøø„”­Þ`Ô½{÷òóò~öîOŸøÒc’µ„ß|ý¸˜Ø7n*\Ee•vÊñ£ôZ,Š¾eŽlC}ýŸ?üðËO?#e3þã·ßÎÎÊZZ\Rôè­¯¯ûK6Ù‚BvvvX× ôã‰èeRÖ…õ ‡ªpëÖ­ü¼¼ß~ðÁ³O=í‰~ð‰/=öÎt!!Á:hULjÍÎÍóòÑZ?î¬Ðpî³¹¹YS]íuîü+/½ì¹·Åýþ/³³²fggÕ1çó /K9Ù:»Ì¬hP úq€D¶¶¶‚B$kp¼|üî,,ªÈöö¶ÙlNMNùÝo~ëâfÏ?ûå÷~úïQ‘õuu‹‹‹j¥ƒƒƒ¸„D­•ãGÉ/(TÓ­´Ûíc££ùyyýõoß|ý ÿâÅç_øÕûï']¸ÐÞÖ¶©À#|atlLÊi—pÁñMYÑ ôã阻{¤ìq/\Tú.+Þ€ÅÒÛk4’“.úûúþùÃñÞ{?üþÞzóÛo|ýõ×_ûÚ›ßøæ÷ßúî»?þÉï~ó[¯sçãbb‹/µ·µÍÍͪWMm6Ëñ£ Z­j½³›ÖAëÑ„÷>ïõÁ¯~ýÎä˜ê¯¾ôò _~î™'Ÿzî™g_záů}õ«?øÞ÷ßÿù/þò§?GGEæ8æüüü¼Z‡ecc#84LÊ9695ÅZ5¡Hçðð0>1IÊ*§º¦öš195¥ÁUNÆ/ hùÞ=f‚FØíöìÜ<)'XaQ1 T†~ ©¹¹›RÔéÈÄÄ$=šloo‡EDj¹?Jrê%›ÍÆ|Ðsw·Ä{Üoll°ŠAeèÇR+¯¨”²Ó ÜÚÚ¢JS½ÂËE”ãGiljf>¨Þ‚Ÿ¿”óª§×Âúõ¡Hmoo/,"JÊZ';'×n·S¨ñ"­FrÞÛg||‚Y¡b»»»±q RNªÔKé,^P%úq€ ®\½&qcØÐØD§¦V3³³^>¾Ôâ'ºººÊÜPë¶ã…—¥œNÞ¾þ‹‹‹¬\P%úq€3D}ÚÚÛ%žK­mí¬YP+úq€MFFG™-*°±±#ñäé2w³NAÝèÇr:88ˆO”¸ñ)Ò•Øívê6E³Z‡(¾O?ÿÙ¹9挢ííí]LN•xæääæ³HAõèÇ2»sgÁÇ/@âÞ§¦¶ŽÆM¹&&&½}ý(¾OŸ °E6ßW,›Í–—_ ñœ ÜÚÚb…‚êÑä×eî–¾1lim¥wS¢™ÙY_ÿ@*ï³&,"ree…ù£8v»½XW"ñl9ïí;11ÉÚ- !¿ PúÆ°³ËLû¦,·æçýƒ)»KdtÌÚÚ³HYå¸ÁX&ýT©ohdU‚FЄ°»»'} dé룃SŠ………ÀàPjnW—°¹¹É\RŠÊªjé'IFf¶ã[³*A#èÇ¢XXXeߌîž^j8ñÍÏÏ…PŽ»£"OX__gF‰ÿæxEe•ôÓ#<"j{{›õÚA?È uH–Æ°½£ƒ>Nd³ssAl«â¶DÅIJ¹àå¸Þ`”~bxûúÏݼÉJM¡ˆE–ýihl¢•ÓäÔrzà¸Î¨Å¥%f—€l6[Q±N–YÑ××Ï­¡ˆåðð0#+[–n¨¢²Ên·SÏ etlÌÇÏŸ:Û  ¿uësL({{{9¹yr=Y€ AôãáìììÈrV§#yù{{{”t‚èìê:çåC‘í¹øú\¹r•™&ˆõõõĤ‹²Ì„ôÌ,Îä„6ÑD´¸¸"KO”t1eccƒªNöý—Ë+*é¯%È9/sw7SNvwÂ#£d™Ñ1q;;;¬;Ð&úq€ &§¦¼}åÙX#"*úöíÛvrÙÙÙ‘k‹ ͦ¼¢Òf³1÷äríúuÿÀ Yn}PHØòò2+4‹~ ®A«\ÛkøøX­CÔvÒ[XXˆŽ£°–>©iéëëëÌ@éÿT¢±©YÆÝììk ´Œ~ ´¦æy_ª=88 Â“Ìððˆ¯ Û^Œ ø[oÉ×Õ”šìï{t‡„EÌÌÎ2¥üS‰Ü¼|¹žoç½}GFGYe qôãÑŒe2Vä)©i+++yžvppPQYåöÛwµâÅO-ÿM5ÉOzÏÓÞËǯ³Ël·Û™“žvk~>*&VƇ›ãF³¾ôãÑ^–±Eò ¦ÎóèÉ„ñ‰¥(‚ÍfKÏÈ’wwf]IéÎÎÕžÛ‹Â.s·Ÿbí)ùº ÊñCËKŽþÄÇ6^½z)êv«««i™ò>ÍŒe&–àý8@ööö’.¦È[*EDEOPð¹ËÊÊJfvŽ§ïZpÀ_÷ÌÿSéýøHÙ˲Ìy½Á¸½½Í\u—þþ€ `yŸc…EŽ+aMŽÐc{{;>1IÞjÉ‘’RýÖÖMŸ‹¯wtv¹ñ(ÎG§!÷-E—㶞ÿò¡\>$,|dt”Ië¢åååŒÌ,Ù_9¹ùŽO« pŒ~ $[[[±ñ‰²wLÁ¡aCCìHî¤Ûwî\LN•ò~ùú|²Þþÿ(·ï,ú†ìs>/¿`mmÙë›ÍÖÞÑáã ûMÌÊÎu\ ëpý8@a666¢câdošIKϸ}û6õßémmm™Ê+Î{ûÈ°OÈ¥+´ßéú_þ‰0á}ý›[Z÷÷÷™É§7>>'À¯ôIÏÈ:88`îC?Pžõõõ˜Øx*§s^>Æ2Óææ&=à¾BÛeî ‘ïNy-4=¡Ä~¼&ûû"Lõ“»ðŒ°ÝÊ[Z^ÎË/䮥edîïï³v¢(ÒÆÆF”o‘;âÜÒÚ¶··G'øЭÆÇÆ®ˆð mvÂ(®_mûÿ¼½Ï ÕåRZÆôÌ Óû¡O§ŠÊ*o_?AnVfVoŽŸ‡~ HFS…`°8aphXGg»OœtõêµÄ¤‹âÜ£‰ªç”Õ§üTÀrüÄ~Ö97oÞdžŸÜA¨¦¶Î×?@œ{ÙÝÛÇ’|úq€"uš{.—æ…Õ†„Et™Í—Ün·_½v-9å’h}nbäï{ÿM)åø|ÃSç.Ç“›_077§ñf|ss³¾¡Ñ/ H¨[UXTâxTÎÌαjE?Pž‰É©ËÅ¥G)¸¬ ­1 ©­«___×ZK¸¿¿ßké‹O¶Ì4|U)ýxzÜ/?QB?~””KiccWìv»Öæüâ⢱Ìäãç/Ú‰ˆŠ=~N–L››[¬ÀƒèÇ ³±±Q¢/;î}),* °1ôòñ+)Õß¼uK -áÚÚZcSsph¸à5nxПzþ‡øåøµŠTŽ':6ÎÜݳ³³£…?’¸1>ž“›'êH8ùt¤¡±åõxý8@Iëšîë}Ž*òˆ¨aKÄ Ij- m6ÛÕ«×òò Î{û*¥Ãm-|SðrÜÞûo±aPb?~¿€’R½Zð\[[kjn‰øŸ˜ôàCґѱ+,"À}èÇJ2<2öÐÞç(1q‰‚—†Å%¥×®]?88PAKxk~¾¦¶NÌ7÷¿·:ÿ·Èý¸¥äëÊ-ÇO&6>¡¥µmyyY~ww×jÊÍËùWAç¼|’’S?ï Y\bX¾wu8‰~ KËËÅ:ý#úqG“RÎyù^—ê ׯßPbQ~ûöíºú†èØ8E÷¶å?¶ßëþŸ!UG?~œ “[ÛÚïÝ»§¸ ¿··7<<’_P(àã÷å¼·ï¥ôÌG?!+«jm6« pŒ~  v»½ªºîÑÕÏQRÒ2”²×‡`P~AaO¯euuUð7gÇÆ®Œeá‘Qê¨k½¼Ï/·|IÌ~¼1ï-••ã÷½Q^YU=>>!ø/‡îÞmïèÌÌÊööõWÄÀ:®33;ï4OÈÁ!àý8@‡†OSý%#+W)­ÖqââMåCCÂtå;;;ׯߨohLËÈôòñS_Q[ôž€åøFÇÿãëó‰Šûñãøúfçæµ´¶MÏÌìïï‹pÞæÝÅÅ^K_©Þ ¸ßùçäžòñX¤Ó/..±¦GèÇ pšUîKnþeÿ …V‡a‘…EÅmí“SSÛÛÛÒôƒûûûóóó½–>c™)áB’øÛÔ¸žÙºgDëÇ iïh¡¿ÿu~¿‹)©•UÕƒƒÖ»wïÚl6iæüúúúµk×›š[róòƒBB:z!a‘—ugz<~¶ËŠÝÎÊ|J?ßéwV¹/—u¡ájØ$4<"=#ÓXfjkï»róÖ­ Ç°¸ònø……ë×oôôöVU×äæåGÇÆ÷öÑZ-›ýPåøݦÇÏ{yi°°.KH,(¼\S[gé럸»¸¸··çô„·Ùlkkk³ssÃ##-­m¥zCJjZ€bv2ѱ N<Ùe8F?Ýðè˜sÐQbãUÙ!ž÷ö HHLJMKÏÍË/Ö•ËL•UUÕ55µuŽT×Ô:þ¹ÌT^RªÏ/(ÌÈÌJº˜ãã@{œQÓKâôãÙ‰¿àŽfüÉ#[pYç¹çaUuÝá!GuB£èÇ"jhjñ\Ä^+äÁœ;ï=ßð¤ôýxEæ|òyñòñ»˜’&ÁÃðêµë¬;Ð&úq€p¦gf%胎’‘•ãëH GIû¥ÄåørË—¼¼Ï3òäá'LJæäJó$,5˜vvvY} Aôã±ØìvSE•dý¸#ù…Åá‘Ñ”qÄ‘ë•/HÙ^ücNò× ^>±ñ‰…E%R> {-ý,@Ð úq€XÆ®\•²:Nrjš—ÅœÆþ{ï¿ISŽÏÕ=Í€“ã똞™#ý3°X§_]]c ‚Öв»»[j0ÉÒ;’›984‚zNã±”~Mš~<%æF›Ü—ÈhÏÅùè´´v° AkèDZô ÈU '1)å¼·/=fø—ýîÿáér|ÔôCMNÆÛ×?5-Söàí; ¬DÐúq€(Ö×7ŠuzÙë!Grò ƒBÂ(ì4›¦¼ïx´·÷þ[tè2Îä8á‘Ñù…E"<ýªkXŒ )ôãQtvu‹Pñ"9ñõýd³ãÿö\?n.~ƒA&ǯ§¤eõè›™™e=‚vЄ°²²Z$ÆËã÷½HN…§ÁÓÞñP9¾kþ_Ac„‰#Q1ù…Å¢=÷*ªjY• ôã!´¶uˆVçbJš·¯?]ž¦rÞËënóãžèÇks¾Çð¿€ ´ŒlazS¬JÐúq€ü—„퉎’_XK©§©ä&þÂíåøjÛÿëãsŽ±ÕrÎyùÄÆ_(,*ù‰WV^e·ÛY› ôãù55· Þ%-#Û/ ˜‚O;™ªù²{ûñ’ÔŸ0ªZNPHXVN¾"w×oŒ³6A èÇ2ÿåñ“),*I¸p‘s;5’¤Èߺ¯¿Ýøä9FU«ññ HNMSгŽWÈ¡ôã™5·¶+¨3:JnþåðÈh*?-Äj|Õ]ýxFÜ/Omn¨›PpY§¸Ýñ V(¨ý8@NKKˊ댎“ž™íBý§îDÿé ç¿»^Žß¨|ÁÔ`BÂ"²sóúˆ3UTÙY§ nôã9µ´u(·?JRrª·¯?= ŠÓ~ù[.–ㇽÿþ{FRSñ º”ž©ôçÛÄÄëÔ~ ›••U¥—GG)¸¬‹O<çåC'¨Êø}´Ýù¿]éÇûJ¿Æ0j'^>~‰IÉ…E%*x¸UTÖð9Ô~ ›.s:úñ£ää†GÆPª2•™?tºßïþ¡a 5²ÕxL\B~a±šžl³³s¬VP1úq€<677‹uz5µHGÉÌÎ  §(TÛÁÞçïµþçúñ¦üï0€ZHxdLN^¡úžiµu,XP1úq€<úúÕW$çRzVGwª+…æD9¾Ùñûù~Âè©;Á¡™Ùy*~ Ý¹³Àšµ¢È`wwWWjTqt””Ké~Á´‡ªÉ\ÝÓgíÇËÒßfÜTœ °ôÌlÕ?Êš[ÚY¶ Vô㌎]Q}£tœ‹)—|ýiUÔ˜_Ÿ©_l~ì¼—ã¦ÎS[ƒB.¥giç9¶ººÆÊU¢HÍ~xXfªÔN¯äHaQIRr*-¹ 2Vþ•Ó÷ã¹~Έ©²OMËÐÔÌ‘K‹T‰~ µééY­UKÇ-ùÅ”K~A4ŒÊMtèÚ{ÿí4åøTÍ—.•%0845-S›/]©qwoõ êC?Zm}£6 ¦;®¤ù²/¹Rc.~ã ËñCËKŠú-c¥¦}Æ5µ›ÊC3:v•õ êC?Ôââ’Æ;¦ã¤¦e‡Ò<*¯* øÛ®ù>º2¾Â@©#¡á‘é™9<¯)3U²ŠAeèÇ’ê2÷P3LzfNHX$-¤²R—óÝG”㶞ÿü'FIÑ9çå“•“Ï3êdfçn²ŠAeèÇÒÙÝÝÕ•è˜LVN^DTì9/zIEÄÇçÜZûÿûyýxûåo2DÊ—_L\BnþežK¦©¹… *C?Ε+×(˜‘¼‚¢Øø ^>þt”â§$õ'-Ç·»þw€ÿGŒãë˜p!¹à²ŽgÑ#²¶¾ÎZ5¡H§¼²švé SpYwáb*x ¿ÿ†×Æ'ìÇ«²~Àà(ñøÍäÔt>§Iÿ •µ jB?Èüí;TKgJZFvXD›®›Ìø÷ï+Çïµþ/ïóŒŒRrÞÛ72:63;§Íé£7˜l6+Tƒ~ ‘ŽN3Õ’ÉÍ/ŒOôöeÓ3^õüÉ~ürò¿3& ÚJ%¿°˜'Œ™žžeEƒjФ°»»[ÌÉœ.¤°¨$95=84œfS¨ÄGüþ°÷ߎÊñ›õO3 ÂïŠãu)=‹GŠ+ilneQƒjФpõÚ J%·$;· &.×ÉÅIékGýø¥Ø_3"¿0Ÿ˜”WPÄ3Äõéô›¬kPúq€ªjê(•Üû:yÊ¥ŒÐðHv'—=aAÙïþWÊ¿ÂPˆ¹ÃxDTLZF6 ÷fhx„u ê@?𸥥eê$%¯ (áB²`0M¨ŒiÌûNLè¡–”œZpYÇSÂ)+¯%ú2›ÍÆ¥£xVGW7E’Œ)¸¬KNM ¤('*ªÅý"¢b.¥g•ð—1Ó3³¬qP:úq€íïïëJ´H‚å)—ÒÃ#£½|ü(X‰b7Q‰»”žE-.HZÚ:Xæ tôãššš¡Bpë•K陑ÑqÞ¾þT®DüøúFÇ&¤gæðá-Å%†½½=V:(ý8ÀƒZÛ:¨DNFVnlüÿ JX"TÎyù…„%\¸˜[ÀçTäLLL±ÒAÑèÇž²·¿_\b ?RDrò /\Le›r"û*á‘ÑSÒò ‹øT*"Í-m,vP4úq€§LNNS)q÷•´Œì˜¸DÿÀ`êZ"Í«âÁaq IY¹|•·ÅŠN¿»»Ëzå¢xJKk;å‘¢“›ùbJZDT¬_5.qoü‚¢bâSÒ2ò ‹ù¬):㓬wP.úq€Gìíí±¹Šš’[pábjXD4§zWNÚŒˆŠ½˜’–›™Ï[¬" xÄÔô µ‘Š»ò¤äÔðÈÞ+'§yO<2:.9•N\½[¬”öö÷Yõ Pôãhï4Siä`ÏäÔ´¨˜ø€ s^>ÔÁÄ1 ‚BÂbâSÒ2ò 8fS™šžaÕƒBÑÜÏf³•”錴–‚˺´Œ¬øĤÐðH¶aÑÚÆ)á‘Ñ ’Ó3s ‹Jø,h-íf>(ý8ÀýnÞš§0"¹ù—S.eÄÆ'‡†{ùøQ"«)>~¡á‘q I—Ò³xIœ”èËl6k”ˆ~à~=½}F亼0%-#.áBhx$—+ñ ñ°ˆèøD qòðܺ5ÏÚ%¢¸ŸÑTI[Dü¢´ŒìĤ”¨˜¸àÐpöcíõð°ˆèØ„¤äÔŒ¬Ü‚Ë:f,ytzûúYû Dôã7[¾wªˆ8·KzfNÊ¥ŒôÌìØøÄ€À`zjÉŽÓL¸pñRzfÊ¥tÇ-àõpâDÊÊ«Xþ Dôã7½BUD\‰uhdhxÔ‘þkk[GEUÍå¢ÏNþŒO =çåC©í\Î{û‡†Ç'&efåèJôÕ5uí]ƒÖá£Ñnï03÷ˆ+YY]e„âÐܬ®¾‰žˆ8]©ñ¨®ý¼X‡F:»ºëš eåù…E—Ò3ãâCÂ"Ø¡åäî(aQñ‰IéY…E:SEUcS‹¹Çrü‹‡‡ÆÜmaúW2vå+ ‡~àN»»»E:==q:†²ŠG÷ãH_ÿ`[{gM]ƒÁh*,Òefç&§\ŠO ôõTÍ‹çŽÄ?0ø³<áBÊ¥ô으ËE:£©¢®¾±½£«Àêôè1ýˆ+ihla„âÐÜizf–’ˆ¸’Šª§ûñ/|ñ¼×ÒßÞÑÕÐÔRU]k(+/Ò•ææffå¤^JOLJŽKˆˆŠ  ÷ ööõ—¬Ow|#¿€€Àà°ÇÄÆ'&]L¹”–‘™›Wp¹XWj,+¯®©kjníìê¶ô xn|˜~Ä•ëôûûû¬ƒPúq€;u÷°Eq)5uêÈÀà¥oÀÜcéè4·µw¶´¶75·646×Õ7ÖÔÖWU×VVÕT8RY]^Qeª¨*+¯tÄñŽÿ§ãtüŸÿNUMã_vü'ŽÿÐñŸ;¾ˆãK9¾ ãËöõoÿ-Bt¥Ff q%7oÞb„²ÐÜ©ÌTICD\IcS«8}±Öb4U0‰+±ô°BYèÇn³º¶F=D\Lk{'=µ\©¨ªe×öGªe)„²ÐÜæÚõÔCÄÅt™{é©åJm}#3¸˜Í­-VC(ý8ÀmZÛ;醈«û3xìüIò…ijic319Åj¡¸Ç᧟–LtCÄÅX‡Fè©åJ{‡™H\Œ¹»— B?p{÷V(†ˆ‹))5RR˘î “¸˜²ò*D(ý8À=®^cóqâjŒ¦JJjÓ?`e׳±¹Éš¥ ¸G›—SY]GI-oŠtzæ!q1““Ó¬‰P úq€{°ù8q=u M4Ôò†2qÃä=ÖD(ý8À VVW©„ˆëiim§¡–7åÕÌCâbÊ+«Y¡ôã7Ÿ¤"®§³«‡†ZÞÔÔ50‰ëÙÙÙae„"ÐÜÀÜÝKD\O¯e€†ZÞ46·2‰ë™»y‹•Š@?pƒòJöd nÈ u˜†ZÞ´ut1‰ëbe„"Ð\µ³³CD\OI©‘zZöt÷X˜ŠÄ-gí²8BèÇ®š»y‹2ˆ¸ž²òJêiÙÓ?`e*×S\b°Ûí¬ý8ÀUÖ¡Ê âzªjꩧEHq‰ÙH\ÏÒò2ë#ÄG?pUSKMq= M-tÓ"ÄPVÁl$®çúqÖGˆ~àªRƒ‰&ˆ¸ž¶ö.ºiRY]Ël$®ÇÜca}„øèÇ.Y__§"nIw…nZ„Ô743‰ë©¬®c‰„øèÇ.™šž¡"nIÿàÝ´iië`6×S¤Óïïï³JBpôã—ôZ©ˆë).1PL ’.s/’¸% wY%!8úq€K›[逈ë1š*(¦I_ÿ ’¸%×®ß`•„àèÇ.ápNâ–TÕÔQL‹“"ž9IÜr¨«$G?pÞææqKšZh¥Å‰¡¬‚9I\OMm %G?pÞÍ›·(€ˆ[ÒÖÑE+-N*«ë˜“Ä-ç ØívÖJˆŒ~à¼áÑ1 âž}zûh¥ÅI}c3s’¸%++«¬•ý8ÀyfÚâ– Z‡i¥ÅI[{'s’¸%ÓÓ³¬•ý8Ày•Õµ´?Äõ””©¤…Jw…iIÜëÐk%DF?p’Ýn/Öéiˆë1UTQI •Á!¦%qÏÑí,—ý8ÀI+««T?Ä-©­k¤’-%ú2f&q=å•Õ,—ý8ÀIÓ3³T?Ä-inm§-¦Šjf&q=E:ýÍÆŠ aÑœ44Äõ—(£L—¹—ÉIÜ’áÑ1VL‹~à$]©‘Þ‡¸ž²òJÊhÓ?`erwm ÄŠ aÑœ±µµEéCÜ’šÚÊh1ÃïÀˆ{>ãu ,šý8Àwî,Pú·¤¹¥&Z̘*ª˜ŸÄõ”èËX4!,úq€3ÆÇ')}ˆ»ö^ ‰3µõÌOâ–ììì°nBLôãg Z‡i|ˆ[Ò?`¥‰3-­ÌOâ–,--³nBLôãgttši|ˆëÑ•©¡…¹ÛÂ%nÉôÌ,ë&ÄD?pFM]q=¦Šjjha308Ä%nÉèØÖMˆ‰~àŒRƒ‰Æ‡¸žÚú&jh‘S¢/c–×ÓÝkaÝ„˜èÇg¶·¿OÝCÜ’Ö¶N:h‘SQUÃ,%®§±¹•¥b¢œÙÊÊ*uqÓ[¥}tÐ"§¡±…YJ\OyE5K'ÄD?8³[ó·©{ˆë)Òé­C#tÐ"§½ƒ“x‰R\b`鄘èÇg6>>IÝC\ÞXN-x,}LTâ–ììì°zB@ôã€3¡ë!®§ª¦ŽZü—˜«Äõ,/ßcõ„€èÇgfîî¥ë!®§©¹öYü”•W2W‰ë™»y‹Õ¢œYcs+]q=]æÚgñS[ßÈ\%®çúõqVOˆ~pf•Õµt=Äõ Ñ>‹ŸÖ¶Næ*q=Ö¡VOˆ~pf¥]q1ŽYDõ¬ˆôôö3]‰ëéî±°zB@ô〳±Ùl=ÄõTV×R=+"Ö¡‘"žK\LKk (D?8›ÍÍ-Šâz›Z©ž•£‰#:‰«©©m`…€èÇg³´´LÑC\Og‡s*&5u ÌXâbŒe, ý8àlnÞš§è!ÎÉ„œ)E:ý!+(ÄC?8›‰É)ŠÂáœÑIÈY³»·Ç ÑÐÎæÊÕk´<ÄÅTU×Q:++Å%æ-q1ë묡 ý8àl­Ã´<ÄÅ4µ´Ñ8++eåUÌ[âb–––YC!úqÀÙôôöÑòcîîuº¨í°Ê^Z‡­C#ê¾æûRWßļ%.æÖ­yÖPˆ†~p6m]´<ÄÅcú­ÃNµ–¾^K¿¼]s{§Yõ×|_øà×395Í ÑÐΦ¡©…–‡¸CY…‹UoCcËÀà°\Escs«ïƒË~Í}®½ÃnédêsõÚ ÖPˆ†~p6Õµõ´<Ä•ÔÔ5¸ØööõVTÕÊR4wtv74¶(ìš»œ¼æû¢+52{‰+c …hèÇgcªà˜>âRZÛ;]ïjëš‘¸hîí(5˜œÞF‰×|2UµÌ^âJú¬¬¡ ý8àlJ &ZâJz-n9mRWjlï0Ky¾¥ÞXÞÒÚ®©k¾o“f/q%ݽÖPˆ†~p6E:=-q:ºRƒ»Êßæ–öâCTç^VTÕèå¼æãtu÷2‰+iï4³†B4ôã€3Ø?8 â!®¤¼²Æ]u­uh¤Ô`rd`pÈÓEsCãgÇÒvtv+ðšÍn|_WÒÜÒÆ2 ÑÐÎ`{{‡Š‡¸’ƦV7VÀíæ¿wîÕ-šÛ;?û.¦ò*Å]s™›®ù8FS%s˜8º†&–Qˆ†~pT<Ä•˜»{ÝÛØ–•Wõnž:ßÒÒ_\bølëä‹–¯ù(uõMÌaâtªjêYF!úqÀ¬¬®Rñ§S¤Ó[‡FÜÛØš»-G_¼­½ËCç[~ÖëU×iüšO¾üNˆ³Û+U³ŒB4ôã€3XZZ¦â!N§ÌTé‰×¥+«j_ü³s/{ûÜû•Ë+kŽj}Kÿ ×ìHÿ€•iLœŽ±¬‚e¢¡œÁ…»T<ĕ݇=Ñ[úŽÎtï¹—õ Íÿ¸ìú&®ù8Ž f&çR¢/c…hèÇgpkþ6q:Ý*mkë¾…©¢Ú½‰èJn쯕~ÍŽT×Ö3“‰Ó;,±ŒB4ôã€3˜»IÅCœŽçJ[ÇW>:‘Ò‘Z—_>>ßÒ‘¦–6å]s³§®Ù‘Ö¶Nf2q:öÃCVR…~p33³ô;ĹÊ*yµ5uR–ãŸsÍ‘¯¹š-ȉSÙ ‡`èÇgpõÚuúâDÎ~ì¤KímmÃÉï^¢/{ÄîçuõM'ÿåâƒ4[¥+úš[O+JÈúñ úqˆ…~pW¯Ò“3Çhª¸kܘۑ²ò*ëÐÈCηlïºïj›Z¥/ÇwÍ}ýƒLlâT?¾ÁJ ¡ÐÎà ý89{ꚥ¯›[w ééí;¹«ÉÑ[ÛƒÖaYúqÅ]óÉÝÏ 9eÖéÇ!úqÀÐ'Òe½´?x†dK[Ç¿žoyÿ¿pšƒ1¹æ£ÔÖ52· ý8”Ž~pì?NΚ"þ¡›„H–ÖŽ/ÆüÏs/ï;ßÒCY…Œå¸â®¹£ÓÌô&ì?¥£œÁµë7èwÈ™R^Q-cݬ7–ßw=Gç^ÖÖ?äÝçήÙûq]óÀàð};½ò…ÙÜÚb%…PèÇgpãÆý9SššÛdìš;:»¼¤Òö0‘½Çÿ—kî:í5›ä¾æ²òJf89S¶··YI!úqÀŒOÒï3¥§·_Þ×T^¥ˆëTâ574µ0ÃÉ™²³³ËJ ¡ÐÎ`brŠ~‡œ>%¥FÙ»æîÞ¾/¼ÎêšzqÊq]³¹ÇÂ$'gÊî.ý8ÄB?8ƒÉ©iúrúT× Ñ;WÕÔ=úѾ~«Pýøé®yP„ëÔ•™çäôÙßßg%…PèÇg03;G¿CNŸöŽ.:ܾþÁGœ$YßÐ,Z9® k®ª®cž“ÓÇf³±’B(ôã€3¸yóý9eŠtúÁ!Ajܺ†¦‡^¤®Ô8h°WÊ5·µw2ÕÉéÃ2 ÑÐÎàöí;ô;ä”)+¯§kzèN Í­íb–ãJ¹æþ+Sœ2ºË(DC?8ƒ…»‹T<ä”iljªnnji»ï õÆrëЈ°ýøç\³I´k6š*™íä4)5˜XF!úqÀ,/ߣâ!§LOo¿P5®uh¤Ô`ú—íÑ;Í"—ãJ¹æ†¦f;9MŒ¦J–Qˆ†~p+««T<ä4)Ñ— X7·wt‰¹ý‹¢¯¹»· ON“òÊ–Qˆ†~p›››T<ä4©­k³n>Þ ÄÜcQD?®ˆk.Ñ—1çɦº¶e¢¡œÁîî.9M:»zÄlrÍݽŽË«¬®SJ9~âšk…½Âšºæ<ùÂ44¶°ŒB4ôã€3°ÙíT<ä S\bùÜËÊêZKß ‚úñ^ó€°—×ÑÕÍ´'_˜–¶–Qˆ†~p6Å%ZòèTVÕ ~襲Êqñ¯Ùqy<È)þ¬¤›5¢¡œÞXNËC¶öNÅÐÄÕ7Ü«j™ùäÑééíc …hèÇgS^QMËC‘"~`pˆ¾Xkikïdò“GÇñd` …hèÇgS[×HËCSE5e±308T¤Ó3ÿÉ#2:v…5¢¡œMsK;-yDš[Û)‹µ\B™ã¬¡ ý8àl:»ºiyÈ#Ò×?HS¬Í4·òË3ò¨ÌÌα†B4ô〳±ô ÐòÏ‹ÑTIM¬Ùô XùGäöí;¬¡ ý8àl††GhyÈ祩¹šXË)+¯âS@>/ËË÷XC!úqÀÙ\½vƒ–‡°¹ yø+œO@>?››¬¡ ý8àl¦gfiy›«‡o±Ò?È|^XC!úqÀÙܾ³@ËCšÆæV bRfªä³@Œ®ÔÈ ÑÎfeu•¢‡°¹ ù¼4µ´ñY ¦¼²š¢œÍÎÎEasò¹[¬ Xù8S×ÐÄ ÑÎæðð°H§§ë!÷¥¹¥j˜ÅT^Å'‚Ü—¶Ž.Pˆ~pf†² ºr_ú¬ôÂä(-­|"È}±ô °zB@ôã€3«­k¤ë!'cª¨¢&Çâ¯LÈ}»Âê Ñά­½“®‡œLK[¥09™òÊ>äd&§¦Y=! úqÀ™YúèzÈqŠtúÁ!ar2m]|4ÈÉܾ³Àê ÑÎllì*]9Neu-u0¹/ƒÖáâŸrœµµ5VOˆ~pfSS3t=ä8fê`ò`ªkëùtãìïï³zB@ôã€3[X¸K×CŽ¢+5Z‡Fè‚Ƀé2÷ð!G)Õ—±tBLôã€3ÛÜܤî!G©©k¤&Ÿ—}ŸâHumK'ÄD?8³ÃÃÃ"žÆ‡8ÒÝc¡&Ÿ—úÆf>#Ä‘öŽ.–Nˆ‰~à SE5ÑËq<£ýìÀàêÁyœ-}|Lˆ#ýƒVÖMˆ‰~àŒÆæVÒÔÜöˆÎ´£«[ÞÒÖÒ7`éTý;Ú‚sYy%Ÿríú ÖMˆ‰~àŒî ÆS¤Ó÷XQ›š{,Ý2¾XÝØÔª…=Lç–¶>,äæ­yÖMˆ‰~àŒÑ±«4>OEUÍ–§Õµõ½–YzÛÊêÚG×÷jŠÈãZN‰¾ì”jm}cEe”¥m{§¹¤Ô(ÈÁ•’Eäq6w³“¦cª¨bÑ„°èÇÎ888 ôÑrNÿvöÀàPq‰A²·¹{-ýŽo×ÒÚ®©r\üqÖËùÔh6Í-m,šý8ÀIFS%½fcé<}—ÚØÜêøOÚ;ÍtÄ¥“ÞX®µr\üqnjiãS£ÝÇEÿ+&„E?pRcS+½6S^Q}¦:Õ:4Rª/+.1ôZú=ÚÛ–WÖü}ct³6ûq‘Çy`p¨H§ç³£Í\»~ƒ¢8ÉÒ7@ï£Õ“9Ï\@·µw:þÃRƒi`pÈSgE64;¾EYy•6Ëqñǹº†S:5šÛwX1!,úq€“®ß§÷ádÎÓÇXVñÙ»çž9C²½£ëèòº{,ZîÇEgs§tj4[ÛÛ¬˜ý8ÀIwîÒûh0 M-ÎU«]æžœíÙàæ3${z?;+Òñ•«ªë4^Ž >Ά¿w÷DS)Õ—±\Bdôã'íììPýh-E:}ÿ€ÕÅ}«iëèrïY‘G×fé¤yœ[Ú:øi-õ Í,—ý8Àyzc9í¦RéÚ Ú½–þ£C‹K =½î9CÒTQ}tmuõM4ã‚ó uXWjàs¤©ôôö±VBdôãç54µÐþh*ænWw÷®®møÇ® î8C²®¾éè«éJž;‘R‰vœëšøi*×®Ý`­„ÈèÇÎë¤ýÑNŒe®÷¶ýÖ£=¬1UT»ò¥ÚÚ»Ž¯­©¥Íõk´‹Pm»¥èvœ-ýƒGï¶äÎÂ]ÖJˆŒ~༉É)Úí¤µ­Ó-ýoCãýÙÓ›uôôö÷¿¥“uhÄ-×ÖÑÕ-óÖ(}–¾AusEU-Ÿ&ídooµ"£8ïÞ½ÚDWjtW=h.Ñ—å¶ö.§ÏŠtû)”æKG§l¹cd›ZÝøÕÄç.s(¤¬¼Š…‚£8Ïf·³U‚6ÒÐØâÆ"¸¥µãø+ÿý É>çΊül×S¥»wî®ïµ ÈÒWV×öXµ0Ά² >Sšø£“öNJŽ~à’ªš:: Õ§H§wooëˆÞX~üõÏt†dm}ã¿ÚëÞ ³ô 8®Mú½Èë›qû—sœ[Û;ùXi!Ž{Í* ÁÑ\bîî¥R}ªkÜÞÛvtuŸü§YªÏÖÖ6«$G?pÉÒÒ2ºSî±7©»{ûîû^míŸ÷/÷•þëÇ5užë¬›?koÛ;Íž.ÇÎÀÔË=÷-çVÆùè—|¾TCYK$ÄG?p‰ÍfãˆNu§ËÜë¹êö¾ýë‹túîÏ9CÒTþ//A—ܾ%ú}€”êËßÅCïΧ¼²Æñãttv{ô»ˆ9Î÷mqN8œý8ÀU5µ 4AjÑTéÑÞ¶¯°è_¿Rª/ëà ÉÚºû‹ÔƦVO¿Ù}´÷™Î´<ó™œ ÍŸí ^^åéŸEÌq~𪈚22:ÆúñÑ\Õcé£ Rk$Ø`¤®¡é¾oz__ÜÚÖyß¿P¢/óÄQ–ÆXVá¹fÚ:ºŽ~œîž> ~1ǹª¦žO™Z3?›õ⣸jrrš&H•ñè¦Ø'÷¡Ö•ïûÖµÿÜóº»Çòà+Æ­mÒœœÙeî9úŽõ n>«³§·ÿh÷íªê:i~1ǹÇÒÏM•qL§½½=ÖGˆ~વõuÊ un,U ÝÔÒöÐïÞ?`-ù׳"ý“æªNîþÙÙ¡]î=“ó¨C´ôJö³ˆ9ÎUµ|ÖÔ—ÊêZG(ý8À ôÆrú •¥Ô`²HÓ~væßûâûÞ?5ü}{“ûÒÙÕ#e?Þké?z±º¸ÄÐÓëž³:MÕG?K]}“”?‹˜ãÜÝÃM*LOo+#~à­íôA*KKk‡”Õmû?7ã~tLÕR^ÕQªÿy­[ÎꬫÿÇ>àºR£çNþTÖ8—WVó‰SY&&§X¡ôã7»J¤¦”èË${yü¿Ã4Užâ¥Ô~éûñþëÑ^á®ÇmíÿUO7µ´Iÿ³ˆ9Îæî^>t*ËÚÚ:+#~à wéƒÔ”æ–vé{Û/,I«kêe)”ihl9¾ §7Eééí;î٥ܾFãlª¨âs§¦£}Y¡ôã7°ÛíºR#­/{î¨Æ"¾O£,ïË uøä –mí]NŸÉéöÓ>Õ1μB®¦´wt±,B)èÇîÑØÜJ+ÄËã.ÆÒ7pt惩oh–±Pv¤¥µãøbþ~VgŸsgr:b4UÊû³ˆ9Î'‡ˆ(:×®ß`M„RÐÜcxtŒVˆ—Ç]Om]ãƒW¥+5Z‡åí”ÑË/éLguÖÖÿËeîî•ýgpœy…\5YYYeM„RÐÜcáî]Z!5¼<ÞÚ.ooÛ?8t¼I·8Wu”Ž®î“Wuʳ:ÛÚ;OþWUµ"ü,bŽ3¯³ù8 1úq€{ØìvÝuQVd<4òd›ZÿµnâªzŒdm}ã£ÿýîÞ¾“;™8þ¹×2 ÈÏ"à8w÷Xø*=ml>E¡¸ [+=­í"ô¶Ö¡‘“‡a¶wš)”úîûÛÀÏ´þÁ¡Ò?ˆ#5uâü,bŽó#Î%ŠÈõë㬆Púq€ÛŒ]¹J7¤è]Ä©n[ÿ¹'IYy•8Wu”ªšº“ãV¤ÓwÎY¦òyÙ¼¸ÄÐ?`êgpœ{-ý|µµuVC(ý8Àm–ïÝ£RnÚ;ÌBU·†²ŠÏŽ²ì±ˆÖ÷õžÜ2å³}iôeýœÕùà˜M­¢ý,bŽsUM=ŸG…¦¬¼Š¥ÊB?p'½±œ†H‘­–©R´Þ¶ÓÜSY]'`¡ìH]CÓ}hú×÷¯[Û:ïûJôeƒÖaÇùÁß@¥¤§·uÊB?p§Î®n"%ÆÜÝ+`u;ðÀKÙâ\˜®ÔxßÖþsoñî˃õnk[§˜?‹˜ã\WßħR‰™™c„²ÐÜibrŠ†Hq©¨ª¶º6M-m9à´­³ÀZò¯gr:b(«`ÄÎZÙ—øl*+E:ýîî.ë ”…~àNÛÛ;lŒ ¸J«×ÒO!{ÖX‡FJ ¦óh;ïûÒÙÕÈ5Í­|<••º†&A(ý8ÀÍjêè‰Çý¢Šu.í]§áòŠjÆÊ]¿ "gtì + ‡~àfÃ#£ôDJIq‰¡_Ô=¾£©ò'òz¾“i;Ýo ˆ ¹wo…ŠC?p³¥¥ez"¥¤±¹•Ö•˜»{=ÂÕ5õŒ’+)+¯äsªˆM•,P"úq€û=t f"ZJ &ëÐ ¬‹©¨ª}ÄÞî}ýV†È•t÷Xø¨*"=½}¬}P"úq€ûQi)"ífêW×céø¼3ië›×S]SϧUüܼ5ÏÚ%¢¸ßÍ[ó´E‚‡C#ݘںÆGXWj´38®§ÀZ\bà3+rJôe6›µJD?p?›Ý^¢/£36E:}oßÅ«Û ÜÁ¡ ÜæÖvFÆ]ijnãc+r::Í,|P(úq€GttšéŒ„M]}•«{ÓØÔzr„õÆrövwcƒéR>¹Âfzf–U E?ðˆé™Y:#awB`ßO¸'ÿf‚½ÝÝž.s^1S\bØßßgÕƒBÑÑ"DWj<88`¥ƒ¢Ñ<Èf³•êËh‘dOm]#¥*QM¬C#¥ŸkÙÓÑÕÍ2¥£xVOo-’¼)5˜­Ã”ªDM1w÷òÑ–=·nͳÆAéèÇžµp÷.-’¼é2÷P§õ¥¶®‘O·¬GT²ÆAéèÇgª¨¦K’+5µ ©D•´³ËŠŒé°²ºAèÇ74Ö¡½±œÏ»Ä¹výëÔ~ …ééY%)£7–[‡F(O‰ÒÝÛW¤Óó©—,ºÃÞÞëÔ~ ›Ý®ç$=©R¤Ó÷ôöQ›í„¿P‘2æ5¨ý8@"}ýƒôJÒ¤©¹Â”h-eåU|ö¥É…V4¨ý8@"+««ôJÄTQ-BYÙ?`•ý­Ãªßd†q>N_ÿ ®ÔÀÀÓ©¨¬a9ƒšÐ¤ÓÐØB»äÙ}K"¦ŽôZú{û但öN³ê_šfœO¦­£‹‡€§sõÚuÖ2¨ ý8@:33œÒéá}»ºÅ©në›­Ãr}÷†Æ–Á!-ì+Â8ŸLMmÏþŽ“9¡2ôãÔcccãRJª§377ÇP;Í~xh4UÒ1y(u MBõ¶–¾ÁŠªZyÞ#nïÔÎ&ìŒóÉX‡F e< <”žÞ>2¨ ý8õ˜¿uëñÿó%O§£½ƒ¡vÅðÈ(“'Rfªp¯íÚú¦†Æ‰¿iwoŸÞX®úÇçÏßsf ¸„È=’{÷VXÅ 2ôãÔƒ~\¶··‹uzj&·ozÐ×?(`o;08¤+5H¹?µcJõem]Ú)Ç燾ØÎcÁí©ohf ƒúÐPúq¥è4÷Ð4¹{Ûña«Û¦æ¶âC¯¥_šog*¯2š*5UŽ3Î߈¼®‘'ƒ{3;ËöbP!úqêA?®Ë÷îÑ4¹1Òo¬qÖý K &½Ñ40èñ3$kÿ^‰v™{5Ø3Χ¸1¦ŠêÃÃCÖ/¨ý8õ W†¦ú&·¤¼²Fü궭½K‚KmmûlKŠª –ãŒóCÓ×?¨+5ò”pK®]»ÁÊU¢ ôã róÖ<}“ë)5˜‡QݽÉ[ßÐ쩳"{,E:½#’m0¢ÕqîSÖ8w™{‹8ðÀšƒƒV.¨ý8õ W–ŠªZZ'W"åfÓn©).»½ÃýgHöXKôeŽ/^S× årœq~øÎì-m<.\Ì u˜5 jE?€ÂÜ»wÏb±].ºx!)*"2Ðßÿü'ŸÈë •[@ôãÊ211EëäJùÖÕŸö Is·åäþÑÕ5õn¿¶Úú¦†Æ‰¤»·Oo,wûÉ«"³¼q µ©¢šgË£v_cçqhý8ÂY__ò±ÇéÇÀ ôãÊupp`àòÏÉé;Meå¾v²í/È÷8+ò¨Âëëtû… éJ îÚüTg`•êË\9ES‰ã,ÂVø†² ž0MgW7 4‚~áX,e•ãôãÄA?®hW¯Ý “z0Uª{o÷8=½}÷½¯úè<¬C#FSåÉÿ¤¾¡ÙC×ÖÔÜ&åi¨¦ò*ǦÁq–=ýÖRÎ~ØQÀëë¬JÐúq„SQ^A?ΡW4»ÝÎv÷E®°%KUMýÉŸ·ÔPöˆ3$«kÿå_Ö•=w¦uh¤Ô`ÒMƒ?«³¶®Ññãtu÷jpœEH_ÿàÉ—å‰#–¾–$hý8Â1èõôãàúq¥›šž¡™:yš¢Ûw£°š<¹Éõg?uyÕCÿÍæ–öûÆÇñ¿xø´Ì.Çw)¯¬ñèwimëüû/Bj4;Î"¤×2 +5òÌ9J‰¾lgg‡õÚA?€pjªkèÇÀ9ôã*P]Û@?åHYy•º_Ú=N}Có}?{m}ãgEöÞWïê& ~yp´Íˆçvéîùì LGz-2Œs(ã,Èn?TäGe%‚¦Ð œááaúqpý¸nâí;ôSe¦J”ãGg$>ØK¶¶už|÷ùÁAšÃ3»Ì½ÿøvfOì|}´­GM]ƒÆÇYt÷ô—4þð1”U°ASèÇÎÞÞÞ³O=M?ÎT«ôãªÐÜÚ®å~Êhª”`Ïk¡òàžE:}wOß?ÏŠ¬xðåzÉ®­¢ªæè¸B÷žÕéø¹?ÅÑWî°2΂ÄÜcÑxE~c|‚5ZC?HÍf³ ôú˜¨è¿ý寿ÿÍoñÞÏüö;Ä‘_½ÿK»ÝÎ$þôŸÒý¸f­­­ÿë&+LJ´VJ†ùà&ÈýÖû–<Š¹Ç"áÎÔýG[Ž8®Ð·¦¦îû54µ0ÎbUäÝÚ­È«këY@?Àsúû½Î{ñ¹ç·m‚”iinaªæ®.úq ײ¾þA¶UÑTÚ;Ì='ðÁÿ±²ºVâk;î²Ë+«Ýò[Ú:Ž@‰ï¸Èã,ÒF+­Èï,Üeõý8OýÿÓ~ûÁoè¾O“ßÿöwLàÈo~ýý8ÐkÖÞÞžÞXÎœšJYyåŽR‘NoéøÂú¬Çmi]C“ë;xŸÙÚÖÁ8 Z‘kï¸ÎöŽ®ÿ¿½óp‹*ËÖ~ÿ;“§gºÉYĈ‚‚¢¢¢¢ ¢ "DÁˆŠŠŠ‚D$ˆ" ((HÎ9JΡ€ªÊo÷0×Ä¢jŸS'¼¿g=÷™ÛÝTZk}ö~ÏÞkáÑ ,ŸL |+iK-niiAÚ@hoo775ƒ>ÐÇEKuM­x”©øÄ×"ǧêZüÔQÉ)i¹¶Ôwé߯ácægõ{rþ§büÌeû’“/‰<êEìð°Ï}@Ÿéé:ZK z/È‚®]Gæ0EqQ_^°A@ÔQ|ûö½®…°-1)¹¨¸r$±W¯“çqÔó±š*Î^XTò]×&—ñ%'OÕžœÿïö§ÏÙð3Ç-7¯ z®â3³’Ò2¹U¶]ŽŽH!f080î¼g¯®ôq€>.ÆÇÇcºy»tç´‚ÂâïÍ0§ÛÇŒO¿¶OŸ³U{½‘•;}¿ökಟ9h…E% ¯^£-'ÐÇ ÀÏ×2·:V[[‹,`N EKKKÆDZ11áOžÞ ¹tCó=í}}ú8/¨oh˜ rK{ÿa†Ç^Æ%räÚâ_/TMΛ֓s*úyù…ð3ﬨ¸ôõ›EÑ1q##£xÊèãFX½b%4nuì¼²F©®ª‚>€>}œ/¼Oÿ(A**úå笨ó ‘3š"~Îú‘kû’“7ãUÇü•RÈo™Qš#%õ=üÌ_K}—.$}¼ºûÒ€>3ŒŒŒ@àVÓŒ GGñèã}üD"yñ¿B_wkÆÆçä@dü©}Ìø4½y §®-é7GÇÆÍÓ«óurÊŒ·#…E%ð3ß“S}ƒSÒÞãáôq˜âëׯ¸Õ·èÑÈ% ôq0EUU ßÕ¨ø„¤y„TØ {—8µA;'7ŸS–—_8C%‘ó¿|Ÿž1#ÞÈ€Ÿ`YÙ9QÑ/ù}åEìàО,@€)¡n«oöv‘K@èãà;oSßñWzœZT\ aQyûœõ…øíMr*¯-%õýŒø&§¤Í–PgÈè1/ã9˜\ö3—-/¿0ö?¯xjeå•x¦}éíéºMÅJŠ‹‘N@èã`ŠÁÁ!>îÙŒŒŠyŸž=Q{•”œ_PÄÁ +,*™Š>~š.žÎþ2>eÁÏB2’‰IÉ|Ç“SÒ ž)@€YŒô  n«oÞ'O!—€>ÐÇÁwxWeånœÙèÆ©zIÎ^ÛìÚ)‘Q1Ù_òþ¯'çÌÅq?¨Á?óÝÒÞ}àÝ 48ˆÊ*@€yö»¸@ÝVßô´uN@èãà;iïy£F½Œ•—_Q¨Ú}tlüŒˆ¿ˆ‰Ë/(šÑÀsʲ¾äÂiBµOŸ³yt´¥ªªÏ À±11P·©ØãGN@èãà;###³uIÚ›·iØ–+lËÈÌš÷1q³ÿá«×Ép—àË‘¿ŒÅýq)íýKŒ-3_ u[}³¶Z‹tú8@Ó©ohä²õüEìÇÌÏP Å`q ¯”)@Ÿ›W_‰áHÁ›·i\š¢cãGFFðú8ì÷2ê6ËÊÊB:} ƒé|ÎúÂM*>1 b¨x,+;W™^ˆp”xìcæç9ÏpÁš¿¶àÙôqØæäñãP·Õ·#K@èã`:“““‰¯ÞpM~Ê+(”Éd--­P Åc¯’’ç?LPPX /‰ÄJJË»ºº%ÉÛÔw\rróñàú8š™µ»rƒÀ­¦éh-éêêB:} ƒéôöõ=Ëí)6.±¥µíûµuw÷””–C.ƒåæDFÅÌSî.‰•–U M …¢¨¸tžÄ`Ù’Þ¼•Édxj}Í —Ëok/Ö‚Ì­ŽÝ½}¹ôq€>fPYYÍíécÆ'©T:ãÚ†‡‡ËÊ+!ŠÁ’SÒ~Pî9=ZEb•U5c³îî.s‰Š~900ˆçÐÇÐ0õuu^Ç>^]] éPðVPX<çQ’œpŽ¬¾¡ñGËÕI™,'7_³úx}}#žÌôqXe`` 1!ÁÇû´Ã–­Æ†P½dïÒÒBPú8@@!šÚ¡™þ!cddtþË“ËåMÍoiï?ÌH—q‰p‹¬­½ã§ÃT{Gg|âk S_ròð˜`~  I†‡‡»ººš››kjjª5ÍzkŠ‹Æ Ö6©))t¢.{‘3Pú8@@'ýQÑ/Ù”œb^&Ô7,`KfgW7Ê‘ ÛŠŠK£câ¦'Éç¬/p‹à Ž“ÁGÉA`rr27¿€åŠäÉoÓär9žÌôqÀÔÕÖÑ]4†?yJ>vó&{ŠŸ©õû¢ææf Z@’±±±·ÉÉL[OO\Í5êY“œ>}Γ.ô ‡%’òŠ*HŠ¶é¥~^½CX°ò’¬Æ¢°ÖÂ+_‹nU³êóªêÚÙ]~JwOOÒ›Ö^ãI$#x:ðS þàÒ… e2=mÁÿ¼E‰¡+»^¹‚`@ èãFn^ÓzS«×ÊÔRø“““µu Ð4l/ãIžDFÅääæà +ãŸú ö(rÿö-÷OßMšgÚZXRRÂô·77·Èå ÕƹBQV^Áô‘’„ê Vˆ èã€oR©ÔÄЈ¢Lvòø‰©O£ûÉæ&¦ãããT€>@`(ŠÙ5 iYTôË’²rJmí¨µ"Tûœõ…dË›äT¸‚Q«.~=‘§;]ŸncùÕÅIŒÕT)ïéíUHFí-\YU‡J}ð-!>žî.ï‚üüïNwg:±Ä„„ *@ <ÆÇÇèÕù!ãÓð°„âu k¤ÖJ]ñóÎÂSý»ú vwž®.~ ¥•º½JJÎ/(‚Ý9>8>eŠ¼4Ýc ¦JÍèØÅ¡ µµ-1‰þ•ý%”ú8àÛ‡m5²õÖ6Ó?¼¡¡Aë÷E?Ÿ\-B $ƒƒ3Ú$ªcIoÞ¶3S£`rr²®¾‘5I±±(Tšg6[F(p,/ɆäJ·Q'œÀ¨ l_ÿ?ûKKÑ5š5U¾¶0Ñë’|fEeutl<­Q+%õ=zr°   z¬ºš‰ÎœÓÙëäD÷+ª«ª8(ÜþÐǔֶöçQ1jjL/ãkjë £—ÚÙÙÅt­•²’œ‚óȈÒ<ÓŠ’L¨®0^X}ñ3åÄñÿJäÍEwhÔT©èëïgt(J¥¹yÏ_Ī9pÅ'&©Ð=‘}±sÞ?€‰ÎœÓIMI¡«Ÿó;‹À >ÐǘšÚ:•¦1q¥e“2;—:22ZYUØXYü^šgþSq$5 - a0õm8ßv!úø…Vj‹_ªóµuõ¬5ÁÎüœ©ê뽘ØøÁÁAŒÿ,èãˆ:sŸý-2™l¹Å2Šßb¨§/‘H>Ôú8aSXT¢B΂Âb2IfùRårEKKâøDž¾’2b{¡´WÇ­¢ä÷ܿ,H'6žgXV’«Âו”–wvu³?võöõ¥Ì\ððõ"¶³³ #?*}Qû’îÎîü¼¼9¿èvp0Ý/z‰ð &ÐÇžOY_””–ž¿ˆÍÍ+ÓàÕQlÚY^’=žg¬¼†(Ïû·j" Æšµ^\¨8>eýN oÅY«Ù¡»»'íý%G°È¨˜Æ¦fŒù¨ôqDͶ­ÌuæœNgg§öb-Šße·Áá@M >g­s€ò@ ¤Ré«×o§ËIqñ¯**ª&&&8{Í““²Æ¦¯ªÉŽ5Åñ*Ôhž²Š’Ðma,XSQÈDžÞŒôÍ_ÞXöã’AŸTǧ¬µðÒüÛÆÛ8³m|N†††rró£¢_N;äæa@M  RFGG YV«­­ÖRüFÝ%Úýýý%*}€xOLzö<úmê»Æ¦f9‡%°é .´"yIIéhþ •įE7 ݘ¶®Âó$áPþ–ò’¬ÙU[«¦>>™§]ZRôƒjã\Ü6>'ccÒÒ²Š—ñ¯È€–ù)Kñµ>€H‰‰a§3çtž>~B÷K†=@(PèãDÅððpOo/ï.[&“}mi-)-WRyl)º¦Ž€ØSp觛ӻ ½†ò7Iò×õìj)º^Z’Á¦¼µ^ùiNäéW¿žµåüžšúø¶_™½m¼£³K¡à™Î,W(ÈÈ W@€ÐÇ)[í7³Ó™s:ƒƒƒºz¿×jõ„•>ð‰DRU]óSå±´¤`2OGõP’oó£¯-~9’¿v®=¹K‹B!û”±Êâ4EÞ?”IEYÞ¢šâDŠï~þ¯ ¹ñôϬ«kJ¥a9ÐÇ#lv朎÷iº_ý)3@5 m…ç©èãŽ_[Ze2ÆÀÐÇ###Fú,w朎Ãæ-¿]{±VGG € @xÊààPeUõ ñ±¹è.õ°¤¤xš8^4œo§ôÞs“’4?„ÁŠÿ8…à­BBöìþ¿Âå©dø·ü~“b|ú8¢#:êû9§÷2Žîß¼…° ÐÇþòG¹•ŽÎéåV$ùÖTÔò’œiÕ0v.èo[Š®BƒU'wz çÛIò× 8¶^(/ùôÓ¿Ë·T-'›‹î’?ÿZDG'Ö—ˆ1ðè㈎͛ì)*b6ë¬zR©ÔÔȘâ5XZ,Ãá8Tú8ÀwÆÇ'šš¾þ_åŠ?SÒÇÿ[΢½Ðo¡+Í3ƒv,l+))î)p›]&E‘û·Þ‚ƒå%Y?úCò¯TNÑɼ%e%9E¨éã G0z¾}qA½ü÷“ÇU¸Œ+—.Ó½Œ”·o\ ôq@HFFzËüiI‡¥%Å%eµÅ1ßrÿªÂŸ×Ç/Dl-âÌ/q|þz;“yÚõÅÏæüÛ†¢'ê¤eO[mq,5}¼Hãà;ÐÇ~¾¾t;s(Ý™s:MZ¿/¢x%{œ\ ôq@8”¯£¢*rÿ6Õ“s<ÏXµOè,ôž_c-/ùÜ^è7š¿Z‘÷)Eu `WmñK¨ÏÜ·ÞWe:µ¶]›ý·í…çÔÌL’$Ôôqb£•6S@@DH$C=}ŠrØ //•/ÆyÏ^ŠW¢õû¢ÆÆF„€}]ßòèW™ÌÓúOÅ*‚$ßzžÝâ…¾ò¼_çúÿt+Ía«+~®t”?Ï®D¯œ¶>ŸõìýAò¨d]O0r¦€>€ˆˆzþœnU“¼Ü<•/&-5•îÅ\¾x !`A@BO4-Ñp,yEɇ©Ýª™<ïßsª«%™#ùkæÿÛÞ‚ý¡9k#ùk’ i,z0ýχò·¨¸Aªj‡Ï¹JÅȘú8"b“­f;sNG&“­XfIñzLŒ¥R)¢ €ò@B£'-Ñp°À¡¿ÀIÍ©(ù0CZ­*N™ÈÓWæo[Š‚ DsÐjŠãþ¦ä×êâ×ß?A’oCãýÍ2júxùŒ€)  JJJ¸Ð™s:!wîÒ½¤¸—q4Ê}¥Ki‰†½…û¿åþEÍ©+~1]Z­,~?‘§§äßÊò~/+ù=škÖSpX%9Û¢´¤hêFóWªŸŸò¼QÓÇóÿñ훃àôq¦‘Éd%%%¯“’^DE= {p3èÆå‹—üýý|}}¼½Oxyyz;yüùßäŸNþííààG’ÿþUâ+ò·åeeíííp)PßÓ>\èÌ9îîn­%¯ÊaËV¨LUeÕ§ÌL2ð†?yz÷ö«þgÏ‘Á™ Ñ^Ç<ÉpMþ÷Ù3~—.\¸~õZðÍ[d Ž‹›¥ÛZ[ÇÆÆøõ“¡‚XvQlZ(É_¯þ‡4…|×UËJr¥yæ ìðy z4×Lå~­]…Ç(êãtíó»ç¹99 ###H3ÐÇ©ÑÞÞž•ý"*êj`àa7÷͛엙/Õú}Ýí±¦FÆmmÉç^¾þñÇææf…Bÿƒù‘H$ºzéÌ9#GéÞ#åå7PæŽ(*,"#öå‹—¹ºÚ¬³ÖÓÖ¡’däß¹ÃÑÇÛû^Hțׯ«««e2gý}à)CCC¥¥¥¯_Ý ¾vÍ™¢b¨Nåñ9k¤¨Puz2O»¤¤’4w¬¢ä£ùð×êâWÿ)_¾š;):eNvÿú>•5ÔÓ'‹—½ÎþþáOžfdd´´´ÈåØ`€(€>®"2™¬¢¼<.öå¥ v;î460¤«ñ-È tõ¶Úoöñö~üèQ~^ï60ˆ|ÉÎœÓÉùò…î…ùùú"Ü`ÎA»¤¸˜ÌtOxy­]cEýåå<¦¯£ë°e«ÿÙsÑ/¢««ª8åèã_hjlLLH¼¸ÏÙÅÂÌ|ú#8àÐ?9%Žk-¼<¥«’ÿ¡Ú'ÔE@•æŽ5=P'†ó7η¥”¨¡•ðž»ýéL~»ƒC€¿lLLEE—7¾ÀMººº²³²#ÂÃÉóËë˜çnÇëÖXYZ,314ÒÑZBæä.371]½b¥Ý[×ýÈÂ9ôÞý7¯ß444°yÐÇÀèè( êíà`§]»énÅ¥kÚ‹µ6ÚÚúùú&&$tvt p€@îtæœÁzkº¯‹†‡‡q@P(åeeäáºg·wmòì÷8rôyd$ËÏû9>p–‰‰‰ü¼¼»w]÷036™çüÐïï´äByÞ¿)éãWþ(;^’.ÏûUµOè.ô€*Íë(<£fJ4=(päZ}•€Cÿ\èbsŸ³ Y_A+`N†††222‚oÞrÚ¹ËÄÐH&ùsç={oÝ OC¦ï8èã?§¶¶öa؃½NNt %³fÖVkýÏž{—–6::ŠhŠ“â¢"ºIõøÑ#Š—þô)ÝË{ ‹™±±±´ÔTo復fŸW,³ ð÷ÏÎÊÖÔôú8À5ª««§–Ÿú:ºJ>‚“ƒÿÆ5Ù±¥èÚ*«lVùFóWA•æŽõ¸ª™#ùVªuøœ»O6ϹzìêlÌ:ìæÓÝÝ ˆ¹\^TX|óÖæ›:«mbhäéáñ*ñC53 ÿü¼¼óþ«–¯à£&>§é.Ñ>à²/2âY[[›ž”J¥H'ÍrúÔ)®uæœÎðð0ݽ½¬mtB†šÔ”òÈäòùžy6•ûžöùøáËB¹Èõq…B1::*á3Âî%Enj ÏÁHHÑœDЂLr¾|¹p~¥årÁ9ÿÊ5}¼©è^}q¤z•^þ‰äܱÁõ³¢·àµ.²t>'Èëêϵ~_´Õ~óý{---ÍøÇ×Ü?£@®0##Ãûä)²žemíl¤o@ÖÎÐÇ™¥¤¤$ðò•Ë,#‹Ï9|;nÛñ¬¯¯ vvtwÝ`ÕòºK´§Šv­^±ò«kø“§xf°ÌÐÐò{O”±ãž^Ô/ÒÏ×—›åÑ/(*,:{ÆOÍ£[1 3󫬕^•>ÞÝÝ÷2îBÀy§]»--–èê±Y†žÑg:™#’®óž½—/^Š‹ëêêâ£xúñÃ‡à›·Ü²ZµšÜÎÚ‹µ„1é"?„üœuk¬»¹“˜ññ£àEsòÉÏ$?–üdòÃ…ÍÙ ™ñêCVøþgÏ™«wè­2šN9fégjúx}ñ³ÑüUj~Heñ{Ó1Iþzõ³b$ߊk/r®{þƒî£ÁaËÖð'O{zz0¸qÞžžÄ„D2[&sæË,y±H~“ÌYæåæ‘58›²ølÛhkû:)‰V]èãÿep`€Œb¶6ë,‹Ï¹fÛïâò69™Ö[)²&'Ó»ù Ñ,Y´øˆ»{sS²Ž"ÂÃé¦Mnn.õ‹¬¨¨ {‘žÇzÁ3<ÆXÇ232÷ìåãZ€ƒúøàÀÀ“Çm֮㎗֮±Š~­¾ª }ü7ö^Ç<§¶9‹Ö,—ZÜ ºÑÖÚªŽ'?¤§+¿“8<üéS¤ ÐUÉ8ÈÐunÛê@wFÒ‹—öÂ¥©±1àÜ9C=}1ˆ/¡÷î AWY}pÚµ[´w§»Z9|f‹Ìb¯^åis*Ï©ëW¯ ¦µ×ÄÄÄ¥‹…ºOú8 KFFÆÁ®tĿpl[îŸ%ù64Š´Ü‡0Í}œÎÖoEÞ?h¥Yê jûɽÿdôIaµzÍðƒƒƒú4BWW—Ë^gþÎ48¥W”—Ÿ:qRO[‡›¾²Y».ý}:ôqUP(©))ÛÄ,‹ÏÞÙ}ØÍ]µ">dÐWáuYJaÈfúõ—;sN'!>žî¥†Þ»ÅEEn‘ÁJTƒ³‘¾Aàå+ÐÇDII‰fOüqÁL òó9x/K$’ÝŽ;1õrvÚ#€öédÙ/Î5ôq° ¤RiÔóç6묙ÈF*ûÇÛiìÆýoïÄíkÑMÓœ©¯bC%7äyÿ¦•fÉÁkS;iwÛþ‹…ç…¡žþå‹—ÚÛÛ1² YéX˜™óz¦Á}üSæðyá±=»HÜ¡+Ëää$™šX­^ƒUÙÌqûŽwiiÊ»41!Aåïzôð!næ8uâ$ݯt;sNg||œ®’µzÅJ…B ¹99|y*3·Û4ÀߟîÁëã555Ɔx O-É***8u;OLLìrtDhþ+‘ïÙËë]äR©ÔaËVqÆú8P’‘‘‘°ÐPFeš’çôñêXj›Ð'ò )i¹aZHý9éI{Ÿ}ÿTóCVšþ›Íɼ÷ÉS¬õ9m­­KÕëë}œš’²ÑÖ–w«æà›·&''¡Ï‡\.‹}¹zÅJ,Æ”,uÿþÝ»Ÿzµ³£C ‚änmm-†o&ä~gÎé\ ¤›Ã?|@€ÂÂB1—Ș]¹˜<ï% ôñù;NÅÓ¸­Y¹jdd„;7õ¥‹”éFnjþÑgÏø‰6pÐÇ2Ï£‡aÌŒM˜ÎÆŒPu M4¿úsO*µýãò¼_)éãA¦9b}.\ÓÇIÆjýö»:ïuÓÿ¬‘&p>ÞÞjÖ¶ó£P(è–o¡>ž‘‘±y“=]g·~CyYôñ¹y›œŒÕ²*ý—7oùüéÓ<Ž=ãã«æW¸¹ÄÎáOžr¿3çtš››é6Í8xÀiÀkêëëI1Ï6sS³§Ÿ¨¿çT¨úøíà`$É º~#Ñ!Y'¶IÊìàr¥øy(+-Uç[èã@yäryô‹èåËØÉÆèËWSj¼tø\S?ÿPí‹‚!LsÄ: OÑ «ìËŸ)}Οþ8û¾þ_rUûÊ~zðWM=At—h_8ŽY ûR3 èãùù;w8 c‚½ ¢»¢ÐÇ+**„] šË^çºÚºÙ¾P¿³YY577c§Îzk^tæœÎ~º%õÛÚÚ |„Œ-þþ¢mܧü[q5KK REe•9«¬Ð:v &žÇŽÙvñü>ŽÕ‡ÝÜÅ5èãàGäææn²µc3=ÔR·þ²uí¿(6ç¤õQ E!LsľQ+¿“Eí Š‰Þo$ÿŸ_Tñý¹q4ÞdèaØÁ4ëª"}¼««ë„——ðÄÌÞÞ^èãßúúúü|}±M‰Ö9 ÿ姣_DSùð{!!Äé’Ÿ—Ç—ÎœÓIÿžîeß B2ðŽQQ,œD†iý¾ÈÇÛ»¿¿úøw^'%!1æ´„øxGgddï½~t(„w=3EMèã`6½==žèd`¯–ºí¶ý×Ã;~¥V\%÷o´>ª¶ø%„iŽX]q4OXšü¡ë/ùM…µŠœ?­Yúo.oꘙ±Éô‘Yäú¸úU¿„j§NœÔxt232ˆYuu5¿Fl꯴¡¾§©ü†:¿Mf«¨0¾ù£Ä„ßrPý,/ùaš#VV’KñdÀH&ÏùÞ]Ónå¿% ûÛœÇåÔ3å°›{ww7Rõyúø ôñ…ÎÏ­­Ö ¾˜áóÈH1êã­--Î{öb¡Åœ9íÜÕØØH\½få*Zç0ŽSd``@O[‡bĽŽy²vñ÷BBè¦ë›×oÜgbb"øæ-l,U³àþB‹ Rßîà€d˜Ó6o²×xt?z„@æiu?äôq<¾Áƒni6!óÃÿªZÂå&(Œ×Žq®þ¸"ïP¥9eãy†´‚[õ*Ÿ3•½SvhÛ¯²…¼%r±ÿ•kC#Õ¶¼€é©<ÓúøÀÀ€ð ªÌcgÏøÍSÎH€úxø“§ºzXe1mzÚ:w‚oSlÊÔÙÑ¡œ³DnNkßÓÓCW$Ýí¸)Áqª«ªìÖoÀ¸ª¾-55{—–&r}|Ý+dÂœ¶b™¥Æ£s#(ø‘=‹ˆÀúú8à#ùyy+-—kþæõ 3söV¾>ÞÛÛK·¹ŒM+--ÅPN ›µë(†ÆÚj-ë4ÊÝÛêëêœåу‡ºK´1R4~ôÔƒ>.ø㪗Þ[j¡ñèÜ º@üÈŸ<å×è}!à<ôq<ÄADx8GN¿™èý&ù¸0m1ìÌß¿ÿùStôñÎj%8ú öB’攵]¥Üúø¿¤ÝU·NýdöŸ´fݶþúÓB+oÿliü—Ÿ/&†F™Wó‘#îîÐÇ秫«Kãgž4{¦vÎS×ÂÑÇ?úD&©X\ñײ>ÆPN…Üœº¡yôð!Ë?!/—rsQ²†Gbpþþ~¼ÔdªÏÏ:ëúúzqêãŽÛw æ4»õ4!U„¤n‰ üÃoCÇ£\ÌÈd2®u¼õý»òÚâ›[›®-Þ8NAŸÈú“ô3µýãm…!IsÊê+3iw4óOëþ¥n†¼ùóœ7ºeÿ.yþÃú-íɶ]ùo^.¤91];vÔCãÑÉúüø‘•””ðk'k6èãxš‹©Têºÿ×rÒ@û·¶7JmßN½ý·%¿ÿÏß^t§ÐŸó}È_)Ö¯)N€$­q«¬ªiiiíïhkk߹ñ>þ/´â«§õÛ;õ¶ÏÓ`Së·ßOîýgEôÿ\íxÖŸbÿfnð¿T¼ªÊ* ¹¢ÝAWïïï?ìæŽ)÷÷“­]×ó¿»Èy¯îsÆöC!Xúû÷Ê© ytKU°Ù™s:‘Ïè&XLt4Òƒ;<ŒD+Nv,ðò•yšRóú â>§½ˆŠÒxtFGGQOéG/´æ¹U¹IoOÈ·§@-‰ÄqÛvn¦å–µÿÍœ·éeΟýûìª^N¿ªÛN3çOgöÿ“ZññÏ»w/$=ý#j–­¤´¼ªº¶¥µ­¿`bbr*çsss§ê/èŒÂüfiò›å¿'²Tÿ„ð€¿ÿôŽXmþo¿úìûç-¿šèýÆÇg®^bB"^婪¬‚>>›éé(¹1Ã6ÚÚN¯JÊo}¼ººÚjõú8øΣéÆ…ÍÎœ3†zút‹L!=¸€L&Ãö^–m¯“Óðð°xôñ±±1œœsq588È…Ñ=ä$ó=íÃÇ!ý€Ë>èã@l§ Ç yí°ùWï»?ÿ¨…ëÖ_çü+Çõê»øxÿ¯'÷RÓÇSïümê–š™ïqÚsñÂ¥ØØ—yù…Я™°²òʆ†¦ŽÎ®¡ááÙ/kß<ý¾¯ÅnÕ¿i…xÍÒ«)¸{îþU>}{ÊÙ3~˜lÏin® ïõñ÷ïÞ‘Å }LgÝ+ºç¹4ø[¨â¼;º.ÈýVÎ{öb¸cßȱ½½]$ú8!øÖ-}†] äÊ憪*ÔÄ›aÚ‹µ”iÀA ¡Q199É‹™Œ©þoÏý½'õÏßÛFüåÜÁê,þáþYsƒßÔÑ:e_þd·êß—SÓÇ}÷ÿsÎÑrƒÍú#îG®_ŠOÌ/(‚´­š•–UÔÕ7´µwô÷H¥ã?Jøñññ“ÇÖBu,+k—ý¡ëiýÖ ÊÊsþįJ)êÛ.GG>å#¯_AŸ¢¤¸»Šç·aaüÖÇ##ž-Y´˜/î652^om³ÝÁaŸ³‹Ç‘£>Þ§üý/_¼D«7ƒnß¼EþoÐõëW®\8ï{ÚÇë˜çÁ®ŽÛ¶Û¬³^jjFæÐÇ2|ÉΦö;s2§ÜMu8A’hÎŽ»õx1éh-Y½b¥Ã–­\öðò 8wŽŒØׯ^#Ã51ò?ÈÿKþ!ùW®û±zí+=mŽÿ(K‹e"ÑÇÇÆÆÖR}YÈw[µb%§z0Ù‚ò?u®\áïØεþ„ÐÇ£uRT_G×ÞÆbÿ®µÎ»w¸r#ó?_ßK.E(Y{NÍjÈÿ ›ÀËWÈút(Cõ-ä1WþØî}ûÔ?¨(§“ÙJIŸd™LVÙn‡Ü®\¾òìÙóŒÌϾT2¥²ªº±±¹½£³`>A|:ƒƒƒ»g»=à· «ÌþÛ$sóš/¼ÊJö£™ÅÇÉlÜjõ2ßçìâéáqöŒßôl'ÿ—üoòOÈ?'ÿ–ü7ä¿$ÿ=÷çðÓ\pcc#†bepÚµúxXh(ŠšþÔÈ 0u[ñR'pnºÕØÀp»ƒÃÉã'îÞ¾ó*ñUaaaKK‹T*Uó÷Êd²®®®ŠŠŠééáádúâvðµÕZéæÐÇÕçØQŠÑTgÎéЭíH )/ BšW­XÉÍÁgí«£‡yó뤤ò²²m:”‡Ü/d &r;8˜L»mÖYsm“¬¡ž~FF†ôqBee%ÝM¼.l]ZZÊ©a||œÌ—š)Û¹Ãqbb‚¿ÃûØؘÃæ-ÐÇxö€›©Hžw›7ÙŸðò"3¸Ø—9_¾y—D"Yð/¬wWMèì}÷gSý?äì{§éèã¡Uy_šÃ–­žÇ<¯^‹ˆˆLOÿXT\*Êâ5Ímí½}}##£r¹|¡¹ÐÖÚºÞÚfî|Óùmø#…(OåÌ”u]°æ~ûì*ßÓ>a¡¡i©©dB«Îº•ü-ùò9äÓü|}·ïàr¡3c“ü¼< È?ß›ÕÙ¹b™¥hõq²¤uvÚן©ñUó!WWþéã2™ì¸§§ªyîur ¾y‹ ¦---,{crr²¶¶61!áòÅKŽÛ¶óëÍ'ôqêôööÒ}7¨©ÎœÓ¡~0êéã'Hö!3Ω–>1Ý%Ú»w’5ä§ÌÌæ~øÐÐPvVö½§]»9Ò“P{±¹­Ä rsr ‘“‰Š¦ÚHÌÏàÀÀ{{ˆã[¶’‚ïƒ<HÅ)‘C………ÜÙœdl`¸ÏÙ%øíEho¬jBçÑÿ-M«y#źÒd¶ÎjmYYYWwOk[{CcSuumiY…Pê†WT×Ô56ý!…÷ôô K¥ãÿWJWu*ÊËçïãvæïê˜Ñ$öɹ…|f©Å·o æîw…BÑÐÐð:)éBÀù¶¶\ÛòB²š\†åŸÒØظjù êã™™œZ}OO]2õ%·Uô‹h²Lþúõ+™OÖkkmMŸ~'øövöë…Ô×ÕñIŸœœ<ìæÎ…s÷N»v? {PR\Ì© E…EÂÂö:9qDˆ>Î&a¡¡t#’óå ²ÚÜÔŒâ²Y»©Â2•••æ&¦\dVZ.ð÷ÿ”™©‘BR©ôó§OäÈehÖd¶#}|jZ¼y“xEØÍ7ÕÕÖqvp 7…ß™3¢­EN~øÙ3~ãããÂêI4/]¼(’’€ÐÇEÈðððš•«4~|¿‹Ë£‡ÉÌJ¡`F”K¾åÿº`­³éTsssô‹hOc÷Ïü®¾8Þ“úçy꤫fåee³´ÙèèØÐÐPoo_GgWKKëÒyM]EeUIi9§ …WTV×ÔÖ566·´¶uvvõõõ “Ù,CZDA~¾±áüþ´0úm4S­(·½ùó켨´D>˜ÁòkàÔ”TooîhŽd>ÿ"* ƒóOéïï?xÀU<ú8®rmvM–cAׯç|ù¢ü‰ÉÞžž°ÐÐÕ,@¾u‹7ú8Y?Ø·_³ÇÖN?žš’¢ÊQ5ÖMKMõ>yÊÌØú¸H ÛuA³9§C½žÒ—ìld kTTTh|Zf¾4ðò•Ù¥·5é–òrrIóoÌaZ˜‹|)}üÛv%&$lÞ¸I\Êø&û„øx¦Ú·ƒÇ‘£¢ªH~ì÷óÅPW[wêÄI}]èã@`ø9£©4314òñ>ýþÝ;–Þî7žX˜ÐY¹ñ›âÿ늎êëãw½ÿAÝ rerùøøøÈèèÐÐpÿ@oo_WwwGGgk[{ó×–¦¦¯ Muõ µuõÕ5µ•U5•ÕåUå•eå•¥eÿ±òÿXEY9±Jò¯È@þ³ªªšê2XÖ×Õ7’!õõkk[[{GgWWwù¢þ¡ááÑѱ‰‰ ꢨIÖçÏJ–Q³–Îçs—йyüòœŸýù× Ž%%%W5¾ßej>¯Ùna<âó§OÎ{öòqOÆ‚ôñ¶ÖV‡-[¹sñ[ìí†= W¥æ:ÎjÕj®ÖÙi?ôq2سÛISGÑÝz›œ¬~q “É>~øàuÌ“Ë%´ S™ÊPîÌù€+ÏÚ––º‡k<ŽE°CCCÝíÿ ÝUqÈÕ5ããGö—JB.,##ƒ\¤¦ÚM“Û\ úøô„ òÔÇÛ{«ýf#}á'¿‹ü:òÉ/åÝp180ð*ñÕ…€óN»v/55ãQv%‡#Ë¥davéÂ…¤W¯™,ëÄ$IZjêÕÀÀ.ûV,³ð¦rèã"¡°°}U…Ü8d†ð.-íþÒæoùJ랥–ß&ûþçÏû’ÔÇG3ÿd¦ÿ›ÆõqqBÖãÊ—l5Ôù­;õÏ*úÁ™¿ÏÙ,êÔ‰“_B¿ÿðo›}­¬¢<ùyy¾§}4.³Ü½}©«$ÑQ/þ(1¿m»©‘1/äråõñ>pdw,ñ-™ñÖÖÖRT5Ÿ<~Ìô½f³Îšúøäää>göƒji±ìvp0¹…„1 G„‡Û­ß}\=|„nY¨¾¾>îü:ºgGt´–tww#g˜¦­­MSQŒ ¯\a¿'„Ê´¶´ Öˆb{òø ñèã³gZCCCíJCffÔeÓÂÂÂv5 ³”ïeûÆØØXOOO»z0ÑÑ=ëógå/€ütâR©´···„ܽ },{»,o¿Ø¡ÁEhÛ ¥$βß&ºf½+TStöïLxúøOyÿîÝBÏryîþUå@»nýuÆÙe2Ëúÿïß:ü‘cÓÿªÜêÛÀ;®ùM"‘<Œ´µY¯A!%øæ-$°jŒŒŒtwwSŸiPÜç¡Œ>®P(HpAîßhkÇPñÀæ¦&Çí;˜»øõÖ6\×Çårù÷Ã,Õf5 ª W›ßþ³ÑØyÏ^èãB‚,¿éžL÷ô8Æ©øñúÉFÖÆHF!³[›µëØFÌMÍBîÜåi³»ÁÁÁ»·ï˜ów+%¿ôq˜œœ¤þÖçòÅK1˜‹õãÏ.{áX¾ó<2ú8Pžä7ÉìMcLLCïÝÑôV|«Ýó}³Æñ›lx®Õ»ä[žê{ŠÓÿl¢÷ôqHª50{w÷o*ZúùOÚ¿}ïS–šúÊpí߆>Êü6ÞÊq’ënÇšš„“¡iÌØÔÇûúúœöh|xÀe_vãelÉ@AÖË 3uÚ¹‹ëú¸·7›AµµYÿ69™õ:Õ¤¤¸X#»ò¡3y ¯3çŒqng†•–Ë9[sCŒïÜáÈ~‹ò°å»÷$IÐõëܯˆ%N}œþä)]§‘X÷÷÷cÜ`‚¸Ø—Ô“<7'Ž…>}\<)(;ïûɳàvp0”ñï¿|â[ƒÇÜâf¡Ö·®Çóým©…Êúø÷2äaèãóPŸ¯òÌÓLÿ·Î· ~#ò6øoäo·;8° ¨±Laa¡Ó®Ý™‡“9*’YlúxAAÁr‹eš-‚ïvðPEy9›îý”™inbJý·øûsZgâTì«©,µx%6É,77—åƒÐÇ™`ÍÊU±ncèýûÈ7¾àuÌ“å¾çüÎööôɇ]]]>Þ§y×CF úøØØØRÚUõoݸ‰qƒUk5ÝHípØÇB‡>.*Òߧ³ðô<âîÎÑ’žƒ™ßj÷~+\ô‡¦™ÿo•vß:B¿ÉòWM§TÇKŸÿE‹1'CÿÄ3Ɔjµà[û¯±O ‹µ¯û rs Ø«YŸ?oµß̾Rù26)-}üñ£GšíoÈÕ•eeü;mmmmméþœÔ”îêãäÞf­ùIà•+Øu¨òòETNôC¯TO™™BíÌ9ÞÞ^ÕýýÈö»¸ y˜€úi†ùmÛVM=•Y ¸¨h“­ôqÁ'¹‰¡‘D"ÁèA—Ô”T&*ép,ôqè㢂éCëæ¦fïÒÒø°b”. #â@š âøا?­_ñïÅÐÇYטÈ8¦¾{ݶÿ:™­l¬»3–‰á¼>!>.Îr©›Sq­%Ÿ?}Bbk¦õñ±±1O .úìí6jüH%Y=íw¡VÃÌØd||œ£úxnn.;oB¶Úo®¬¬Ä ÜÓÓãqä(ôq>rØÍ]À9§sÜÓ‹î ö¯_¿"èòñÆÊÍ6#}ƒ¨çÏïR™Lö ,LO[ú8w ³1C#Tä8›·Ð‘Ý[xU@JÒÚÒÂèA.g§=Â쯘üV¨½P}Üwÿ?¢@ŸÍðð0Å®’Gwþ:ž¥D¬óÿñm¬V¾tÖb÷ÿX‹qQonj236aaÛøÝÛwPƒx:¯“’4¸‘ú¸ tuu »3çt òóé¦ÜµÀ«H!Š´µ¶²6€ìÙíD¾N<¾­¯«cÿ&ôñy¸tƒ®ë–ššI¥R #´ÈÎʦžÞI¯^Á±Âú8P’aaÌ=1oݸ)ä-´m×$Ž¿¾ËxÛèã³u¥½NNt¼Ëö_=©óÖ"Ïûó·Þ8z»¬´ŒMAs¥åò®®.$¹aNÏÈÈДdG~T€¿?ϼ†Ü½«æO[»Æjbbâõq²>¤^Gf¶­^±²  ÷íl:;:Øo¬}\eî…„»3ç èN,ÌMͦÆA >“““[¶²slðÉãÇâ\ÆÜ ºÁÚö|èãóÓßßO½‡jøStU¢õ’V«VcG…`€>”d‹½=C3™ø8¡K„²ÁoEJo!¯wqÝú8›ø9ÃHÉ ƒß¯ÿMž3W  ~ûÖ—(Z‡“™|ð­[¬m$ßj¿y||y®)ÒÇï…„hj1h·~CQagþ26Våm£FúU•USŸÃ9}Ü÷´Ó¡uÙë<44„›öGà  öûÂA_( …bÕŠ•‚ïÌ9¨çÏéfÝ«Dì¤Càå+,ŒkV®*--³Ÿ³²²,ÌÌ¡sË/ÑõÞŠe–“““LÔ§¬´Œzn¿ˆŠ‚côq  ýýýL¬†t—hgfdŠÂƒ}‰J‰ã ÇÈêóÛvZP¬$ }ü§Z³RÚªG^ü{Sâ_9ÿÙ3^búí«ÿ·‰Nx¾¨°ˆ,gØ™–ûxŸ†Ã5u}|dd䈻»FÖwzÚ:÷BBd2Ç}þ)3S…VÃ3ÊÜÒÇããâ˜Žî¥ °HRSRô  s™ŒŒ º!xö€ã?™<覥ãöH$õÉÎÊfáÚÁ®ÃÃÃðvww÷‡mÐÇ5Ngg'ݦÁÄb¢£‘áêsôðºq±\jMXBú8Pn)”ÂDyOò±"rb[ÐOêPwüOï ©TJfæÐÇ™¦¢¼œÆ6\öõ÷õ~Sà´îÿ ‘HŽe©³btÔ 8\#ÐÕÇ7XÛhdq·m«ùv¾¸½¾®nAŽ²´X–Ÿ—7ý8¤744P?­<£\NdÄ3Ü«ÊSSS³jù èãœÅíà!º‡=9Û™s:çÎÑM<40Q“ÁÁÁå˘®_½&’N÷Ê011qêÄIèãçì?º\»Æ ¯ðÕ„Lâ©Ÿ<åþËc°  e ~HˆØ£EçÇîÈo¿Ï!Ž×ìü66Ç ¼««‹¡srÐÇÿ;oXMõüñœ¦õû¢à›·0uŸ2µ`¡ÖŠîm‘½Õç¢>ÞÞ&†Fì/ët´–„ܹ˻…‰T*½réòOk­ÿà¼ÀàààŒ?çŠ>Nü¾m«£ÑÛº dŽÂB9xèã*ÐÙÑA÷™êéáÁ‹^SSC7ñÎC:©ÃÉãÇ™žØ¡ Î&Öì‚>>––êk›×IIÈmu ^¦ÏÔÈxddŽÐÇ2Po]èæzP¤®œìûÖú­Öù[¥Ý·š]ßZ¯~­šç?Ïúü™‰é ôñ)X(Ñ`¤oð.- ®þ)_²³ÍML™‡Õê5˜Æ°Ç[Fý¼DÒÛï%¹ùHssóµÀ«³÷’èêísvyôðaoOÏœÈ}œz›ÁsÄRè·;8@çwoß¡ëò„æËo§ÛB–Ìá0iP™ô÷éŒ Æ†ÙYÙðóHzõJåV$ÐÇ©@ýýÝú Hl•éìè ~Gᬀ èã@ÌMÍ(Ž$&†F?Zƒ¹ž­' 3A\ìK¦§‚+–YVWUÁÕʪxMMk×X1_ˆÜ®fþêãäʯ_½61!²H£££ ýýý?ÝÏ }œŒ¡Ì­ðÉ'§¿OÇ-ª‰„ÑÝýÐÇ ¹±WZ.UgÎé¼NJBã5ŽŒ ŒVVYf¾”<ÌàçùÉÊÊb¹WôñéÔÕÖQßæöþÝ;$¶j\¹t™n, tõÈdŽÐÇ23ºƒÉ½xUy:xÙ }üëׯLÏí6Øvvt ™f°°1åí[¸šMxª¯´\ž››+æÀi^—Ëå›7nb(ÀÚ‹µ¦ú½5fºÐ ôqåùNyÓ.¿Š«NNNÒ-M¸ÉÖI¥—.\`n@Xn±ŒGÍ@4Kaa¡ ݺ¡Ó‚úQe‡-[‘Õ*080`¨§O¹©ûÅ‹p¬ð€>~JCCݣ̳‹œ‚ùñ>y ú8E …ã¶íŒNw;î”H$H]J¥®û03c“aa>êãî‡ÜÈ\ZäÓ¼>ù,’¹£!'E:;:Ý+ }\y¹ºŠ°3çtnÑM¿¢Â"äÕ‚¨¬¬d®«ÌJËåÍÍÍp²ò”k¤s ôqYrS÷dVV²z¡P/;FŽØ'H ƒŸ’›“Cq09ìæ—.”ü¼<èã|‘\ˆíwq‘J¥È[•‘ÉdGŽ2#¾4üÒÇõutÉÔQû¦q}¼¯¯ÏÔȘ¡0_¾x ¦,Á””è.ц>®Y:::è¸||X¶µµÑuÂÉã'Z ‚nø… [ZZàá…RVZ¦ñ]ä¢íƒ½ÏÙ…®'vîBJ/ˆ±±1êM®|¼Oñ‚ú8ø)?| 8˜D„‡Ã¥ E¡P,¥Z^ÌúxWW£SÄÃnî“““HZõsþô©SŒNÔ3>~„ŸÙGúøF[ÛºÚ:„l ëãÌ n‘!¦™áA×,·ƒƒEÛ™s:t7Ñëië ˆþ<‘ò$¿Ifîô_mm-<¬¹99$“¡³õmnÄ ‘ÒÊþä)õöDM(ñ$P ƒŸ’òö-fÚçØQèãT`tcò}û!ŽÓB¡Pxód.X«W¬ƒŸY€/úxÀ¹sãããˆ×w4©WTTPïj5e6ë¬QýŠ9\ö:C×r¹œn•~uæœNFFÝ |ôð!LÈC”Ì®˜ õôKŠ‹áaux—–Æ\Ýèãó@ýD…ëþÈg%‘Édt{Vó8rŽ*ÐÇÁO!3ŠãIUe\ªa¡¡£P]]-N7~ÊÌdnâ·g·ʪPŸÒ¸rc.dA×®ÃÉ,À}}ÜØÀðm2:5ÎD“ú8õóÈß#ÝÐЀÐ2GKK‹¾Ž.ôq@¼$æÎœÓQ(V«VStÅZÞ¾*`™'31t“iDúût¸W}žED@gŸÌ ÊëO­ßUVV"Ÿ•!îeõd®¨¨€c… ôq Ä|;ã‰ÆIMI¡qÖî“Ëåvë704ëÛj¿ytt‰J‰‰‰ÝŽ;™«4ÝÞÞ'3 ÇõñÍ›ì¿~ýŠ0ÍFcúxΗ/ ;5%qešëW¯A×öí§Û|¬··—¿ÞxF¹'ÞçÏȱù‘H$æTËAbÿ>œ÷€>Î>d®‰-ÌÁf5õ>cðª€>~Ê—ìlŠCJfF&\ªÕÕÕ£ N%7:ês•:zzz¥ 144´ÞÚ†¡Øðò‚‡™†Ëúx€¿ÿÄÄb4'ÓǶle"ØgÏø!¨,088h¨§}œeÚZ[éµÇŽò»u?ÝjˇÝÜ‘fós÷ö&†nôÁ£‹\.wÞ³ú8ˤ¦¤R?Tóp?%-5•z&çåæÁ±ú8ø)åee4w<ÀUJ¥´j±Z.µ¡GFFÈÅÄ|ÏÄШ¾ ý˜¥µ¥ÅÂÌœ‰ð‘ÛJÌåøÙ›ú8jªüÍèãÔ!OÙkÀb 硳̭7éú<;‹÷ý‚N?AÑ!Ú‹µ:;;‘i?B"‘˜Sº7ÙÚaè¦N__ߊe–ÐÇYfíÍ>§OB2ÏÃæ-t}¾Ãa¼*l ež¡8’ÂlÖ®CK•ahSË’E‹322œ,Ÿ—§£µ„‰ :ïÙ ÷2 õñÍ7577#4ó£}|Ïn'êñ&cŠ»±Iee%ôq6‘Éd–T;s £ÜvQaÝ<¼Œdû¡÷î3ñ»¹© ¾e‚‚ü|†fÕÐÇDbB"õ¹M[[’ùGЭ0e?|€c… ôq  FúGòîîn¸T/_A?Õ`hS ±;Á·‘™¬þä)C“ö’âb¸—9¸¦ûxŸG\~Šôñ²Ò2&B~3èÂÉ2t»#BŸêGÈ„… Ã3›lí(ºe¹Å2™L†|›T*]Ê@åñÄ„ø–9BîÜ…>Î&dô ûdü£Jà¹sÈäA½ŽÝ[xUð@Ê@·¥Dà•+p© äçåQ©&!Â7Ía¡¡LÌô¸ìCZ²Œ§Ç1&Byð€+|ËÜÑÇõ´u¢_D#"J¢}ÜãÈQ&*« Æ<ûœ=ã}œ5ö»¸ 3çœPï<ƒ¿sò"*ŠúЂïL#“ɶÚo†>Îë;…ÌkÑkNèž²×IIp¬à>”áœßYº#ySc#¼ªmmÕt¾û!7±9M*•2Qºš|¦`Ö”!1!îã°eëää$»P>~ø æ– šš±9-2âÓ¼ééHH››Ë„†æéq ¾e.èãûœ]‹Á¶>~'ø6õÀ÷ôB 53RçäPŒcY)^mýAAèÌ9çýè6õÆŸ0ÑT9>.Žåï“úø<Îcccæ&¦hÌ(d¡N×ÖËP©O$@Jbk³žúƒòÒÅ‹pìB‘J¥N»v«àm?__º+;‹~çj 3óÁÁA¤¢]µb%õÈbzÉÔÇMŒÑj^eXÕÇÕ<5§ÝºqQÔ ´Žík/ÖBGÝ‘š’‚Îœ?Åiç.Š.236!sqäÞmmmtŸñäÓª««áX¾?¡Ïýê“Ý‘‘8vŠÎŽ­%t=üèáC8V$@J|ëÏJïÓh¿PÈ´ÜÏ×wASÍà›·Äé«ÃnîhÎɼ²›–Z`8bMéãvë7|ýúþWVõñ#î‡é†ßÜÔL"‘ Š„ÜTBio·ÎüÎ{ö¢3çOI~“LwxIˆGîMq÷öœ/ªí½‚>®ÃÃÃtû"{öŽâÊ¥ËxýTú8P’šš†—N;wuwwÃà %åí[k«µÊ”z/,,§‹:;;µkQOWäG8xÀ•úp”š’ÇRG#ú¸Ç‘££££p¾:°§“…‡¾Ž.6ûŒ ç©„òœßY8sNš››µ~_„Îœ?…zšm[~SX­ZMѱzÚ:ð*û”––ÒL ÏOÐõëtÝK†8œk!  êéÓõmð­[p¬x€>”g‡Ã6†ž˜KMÍ K©€B¡HMI=yüÄìVØvë7\¾x© ?_Ìþyôð!õBÆåehÆêëë©¿ÿ8ìæÇR‡e}œ|8{-P‡=}üuRÝ$036Áë“‘‘A%š)oß™srýê5º7NVV–P}uëÆMº¾ª¬¬DæåæÑõê•K—áUMÁÄ‘[èã?¢··×@W®‡##žÁ±ÔO´0  ý©˜€>4¸€aGÜÝÑIe†††š››««ª:;:P¨s {»tSôäñð*§ð?{Žnˆu—h£¸{Ÿ2õWtÁ7o¡d(PŸºÚ:ºÉIV¨eÌ5:;;ÉzŠn £_DñtaMGÁqº°¤ŒŒÐjä8eú:ºƒØìà îßV3šA×®ÃsB½¦vXh¨°=ævðEwêé‹|¹"—Ë龡ñ=íƒûZ³ìÙí}œ½5 m$ã^Ɖ٥áOžÒõ' P'*>‰ èã`AD=΂Æaflr;8¸¿¿*Cý(-6sê[ÈÉê^¥ ;ú8 ŽS‡%}<ý}:ÝT€ÈÂÈ=¹b™¥:K‹¡¡!¸qNö:9ÑUÙ™s:Ÿ?}B5ŠäæäÐõg}}=îkÍ’™‘ }œMÎøøÒu²µÕZ…B!NgÊd²•–Ëéú“Y*6 ƒ…ŽÞÞ‘ÏŠ ‹ÆÆÆð×ý(&Ûº5Vp)DZµYO1âæ&¦¢-ßÇ -µö9» £°¡Çž¤û­K8ËàààÍ FúóWÖ;çw¶¯¯7¯_£3§ÊxŸd¦8>Tãéã'šÕÇg—©´¶Z{ØÍ,¾ÊËÊFFF&q"—Ëç_€/ÔBîÞ…W9Îðt‡”êª*x•Lèã—¯ 5Ó°¡û9C1-ö»¸ lgp`€ÌÒNxy­·¶152Öú}‘®™Ày9ú"* ¯7”Áiç.Ê9{zÄã½’âb¼]PŸ#î‡QÞG¨D¿ˆ†>Î&¥¥¥Ô½óå‹xø%;›ºÅ\;Kä@*sÈÕ•Sùœ…Ë·;8œ<~âîí;d9VŸßÖÚ:99‰Ø ›ŠòrŠYDï---ð*Çéìè +ÂF>‹„WiA74zÚ:d<‡WY€ }ÜnýŠÉñ"* a¦¡¡î\Y$9§³y“=E®Y¹J„'Î(Vø171ÅënN100Àľèãóà¼g/]o;;í÷T6Çí;“¢ú8Pçé¹b™%Ç%ò9åN’«[í7vs¿p>,4ôUâ«ÜÜܦÆFl9áOžÒ|DnÛ—ò§]»©6e9—Ò‚â:ËÒbYIq1\ÊŒë㉄br§{WW„͕K—Ñ™SMbcbèú0##CTl¤Z|\´5ܹ̇mÐÇÙ„z'%b"™.——•Qw: ˆèã@*** õôy'‘Ïc&†Fvë7ìsvñ=írçn|\\Η/ÍÍÍããã7_ {èóу‡p)/ û^d¹Å2¸”%Ð×IIð'k0®“ç+Å›vóÆMˆ6d2jnbJ³3çªÕ"tãØØ™îSt£›ëAQ90îeEï%&$âÖæd }œe·m§ëp‘ŒKG¡ë·M¶vÈF1}¨É‡ôtíÅZB’ÈçÙuî°e«×1Ï›A7bcbȺ¾­µ'9Ýc õõõp)/hnj¢{×wvv«T ¨'¿I†?Yƒq}<ü)Í—ZW3 l’^½¢ûœ ½_œž¼táE7’‡\{{»x¼àïOÑ{¢*ÏJJJ ³LÆÇÔÅ‹êêja;­±±‘z- 7¯ß Å ôq@%‹È,x‰üGmÖ®±:°oÿå‹—ˆr¾|éìè@JhÁì¬-ÖVkq`šƒ@ç)ŒëãgÏøQ¼c3323 lv9:¢3'êëëé®nݸ)ïmwp å72oÃ}ÍAd2™®ôq–Ù¼q]Ÿ{ó¶Ç|OûÐõØÚ5VØü(r *D>¯D>ÛÈŒbó&û“ÇO< {ð)3Š9›äæäP ¥Ÿ¯/\Ê#Îù¥ý°ÐP¸” ÐÇy ãú¸ãö÷oJ$Ä ˜úº:º³Õ£‡ˆÙŸ{v;Qt&YËd21øM¡PPTN}¼½qks§» ³LÊÛ·t}N¦FÍMMBuWgg§ŽÖº‹~<9ÐÇ-"#žA"Ÿ§¬ù.GÇË/½J|ÕÐЀlaºçõàRA÷è9ZFÑú8Oa\§XØÖf=„Í¥‹)wæüüRE{›,ŠçÓׯ_¡F‰ ëס³ŒB¡°YgM×í¾§}„ê.êݪ—[,›˜˜@Šèã€"df¨¯£ 5ü§fl`è´k÷Í Ÿ23±ã.~¾¾#ÕÚÒ—òˆöövŠÑ·Û` —Rú8OaVïëë£x»b"6R©ÔÔȘî~çæææÓØØH·K'™Ù‹!éVI.--ÅÝÍMÈ| ú8û$ÄÇS/Û!ē샆zút}õøÑ#d €>èBæ9–K- €/èäÓæMö—/^ú”™‰w–ê³×‰ÚyYsSø“w,55£X( þ¤ôqžÂ¬>^Q^NñQú,"&1!3fî›Zº?yü˜bÿÀÑÑQÜÝܤ®¶ú8ûÈd²Õ+VÒõüÅó„稻·ïÐõ’™± †#ð ú8`€ÎŽº „DU¸ü°›{lLÌàà I5Ö¬\E+{œàOÞá¼g/Å[²¯¯.Uèã<…Y}ü]ZÅ{5;+†b±~svéÂÁ§âÅóh¹ËjÕjÜÚœE&“Ñ-î }œ}yÐÛÛ+$™›˜ÒõÒàÛÈ=ð ú8`¹\|óEMDl¦»Dûˆûá÷ïÞMNN"45—»|ñ\Ê;/_¡x'–•–Á¥ê}œ§0«ÓmÑÙÙ‰€¡R[[‹™1_Ú I¥Rag£›ëAZîÚïâ‚»›ËX[­…>Î>ããã–ËèMA×® ÉEáOžÒõ¡žþàÀr|ƒ>˜¤°°ÐÖf=fËjžõ ð÷'+#¤“2´µ¶Rt~L4šñؘŠ9òö-\ª>ÐÇy ³úxà•+6ˆ0w옶—±±ÂÎF{»´|uöŒîn.ã²×ú¸Fxôð!õÖgCCCÂpŽL&[i¹œ®/_AÖ) F™œœ ¹sWO[fõ»þ¤¦¤'’jŠ‹Šp^_ä|ÉΦ˜áOŸÂ¥ê}œ§0«{ŸÎS˜ÕÇ)ö<ヵ ,Û0ñå—ùžöj6 PtÔÇpƒs™gÐÇ5ÅÐБ¾Ý¡éñ£G|w ÝÖîÄ´kaC˜ôqÀ2555Þ'OÑmˆ-N352¾"ø>@ ‚<÷)öX‚?y Å“èžÇàOõ>ÎS˜ÕÇ×[ÛÐJ‹ëW¯!Z@TWWc¾Ë;3ÐÕL©ßÐíóSTX„{œË¼NJ‚>®AÈ܆îÐdi±l||œ×>qؼ…®O°Ò3€>4BgGGðÍ[+–Yb­~Å•W‰¯QSÜ ºA˱V«×ÀŸ<…ÄŽV¸ìu†?Õú8OaV§XÄ6,4Ñ‚$Àß3]>šP»—ÔÔÔPôRCCîq.“™‘ }\ƒôöôèëèÒš¢ž?ç¯Cr¾|¡ë ­ßUUV!ÓÀt  "—Ë322Žõ0ÐÕÃ\ZÛ¶Õ¡¤¸xù -—:lÙ ò;Zi°ËÑþTèã<…Y}ÜÔȘVZDG½@´€ðCgNžÚz6 &‹ Š^jkkÃmÎeòró k– çéMkV®’Éd<õ†Ë^gºÞpÝ9f}p©Tš–šê}òõ^Íâ±%‹_¾xIäåV(Î"öìvÂÉSœví¦øæ þTèã<…Y}œâ‹ñÄ„DD —±±˜Ýò×rsr„—“]ÔÝÝÛœËA×,íííÔ‹Ò&&$ðÑååÔGi2 !ÇÀ  N!—ËKŠ‹ï…„8íÚ­»D³ë…šµÕÚÂÂBÑæß™3´<¹ßÅ÷#OÙçìB+ 6oܪôqžÂ¬>Nqɇ´‚„âa(ûv쨇ðr27'‡¢‹p›s™ò²2èãÇÇû4N·<Ž¥ëœs}p–±±12 ½wßíà! 3sÌ´•ßH~ýê5¹\.Âœ9}ê-7º¹Ä=ÈSHìh¥­ÍzøS} ófõqŠ½´ÔTD ŒÊÊJÌhym:ZKzzz––_²³)ºH¨]L1 A§HSc#Åiô”¥¦¤À È.0èã€/´´´¼MN¾tÃuÿK‹e˜xÿ´I¸/]¼HËo$Opûð;j³ÇmÛáOõ>ÎS˜ÕÇ õôi¥EÜË8D ‰-ööP–…aöíRf675QtNee%nv.“–š }œ#”Sòró¸ÿÃ)N§,6&~ôq N EOOOEEÅÇ¢_Dß½}çì¿C®®dIB2™ú&ùbëµÀ«´ÐÇy ³ú¸™± ­´òÑ‚î]˜f<ÿZ´Kš¬(:';+÷;—‰‰>Îö:9Ñö9»pÿW‡Ü¹K÷W¯Xf999‰t?ú8³!Ãf[kkAAÁ›×o=|xåÒåÃnîvë7èëèòwŠr÷®àw?ä4`¹Ô‚V¸rƒ?Õú8OaV_i¹œVZÜF´€`ð;s²²,èÚuÁ$çøø8EϼMÆÓ< ƒ>Îr¾|¡>:•—•qù'™Ó®–ûôñä˜èã,ˆÎŽŽÜÜÜؘ˜ëW¯ru]µ|¦èááŽ΋¨(Z¾ÒÑZ‚lç)«'ùžö?Õú8OaVßhkK+-.œG´€0¡~–¦Y[jj&¤íŠ;Ç>‹ˆÀ-Ïe®\º }œSlwp ;:vsçòï ú”îï571C"y€>€š åçåEF<ó?{nÛV.W6_²hñûwï‹”·o)º«¯¯éÍ;úûû)æÀµÀ«p©ú@ç)ÌêãN»vÓJ Ocˆßóøc¯“’“¢ëÖXÑrKà•+¸å¹ÌÑÃG sŠééÔÛ”ÕÕÖqóÇÊd2êûERp¨ôqè2>>^TXôäñcOî.7ÐÕãìsP}èž<+--E>óŽ²Ò2Š9ð , .Uèã<…Y}üˆ»;­´Øá° ÑÂ`óÆMP“…g»…Óóâ«ÍcG=pËs™­ö›¡sM¶vtG§“Çsó—ÆÇÅÑý¥FúƒƒƒH!0?ÐÇ`”ŽŽ2¼ŸðòZJ»|–Êf³vD"¤·kkkQQäÐ=Cû.Uèã<…Y}üŒ/­´Xn± Ñ ´´R²PÌP…‘¥§O¢å“­ö›q×sŠm´¡Ó‚̃éMÚ‹µZ8ÙCx½µ Ý_Š+@ ÀU•UÃ8íÜEQ-RÍŽ>"HK$Š^ºrIË;Bïߧ˜_²³áRõ>ÎS˜ÕǃoÝ¢X;lbb|‡âK£©>*¬m`*Ý‚‰çý„‘¥w‚oS<ÓªP(pãs“žžº‹OèãT ·ŒµÕZº¡ñ;s†k?ó]ZÝߨ»D»»»ù~ ôqا·§çET”óž½Ú‹µ4%‘“{_¾571¥WÒç>ù‡×1OŠ· 7wTðèã<…Y}<&:šâ½ZSSƒ€^#‘H tõ(Þ'¼¼àUuðô8F1Ɔ£££pKÒ«WÝòõëWd7ÉÎʆ>ÎMâb_R׎;;;9õ¶l¥ûÏžñCæe€>€éïïzþœú#@É\mmmÂs)ÅZy6k×!EyÇz§ñ–,Z,“ÉàRõ>ÎS˜ÕÇ?úDuáýX’M·ÜÜ\xUˆéF$úE´ÜRQ^NÑ'ïß½C¦q“§Ÿ@ç&4®\±’nt._¼ÄH·ŸØT ¼ŠìOÆ  2µµµþþFúlJäûœ]„çÉcG=(Ê£###HN166FñL™|Â¥T€>ÎS˜ÕÇëëë)>Ïnݸ‰€^C·ëÞðSÁf5Å ØÛm€OÈÌXë÷E´|tý:ÒŒ›Ð=?}œ.‘ÏèFÇ@W¯¿¿Ÿ#¿Îe¯3Ý_wܧ©€²@€;H$’G®´\ΚDž˜(0ަ蟬¬,¤% »á`¿‹ \Jèã<…Y}|llŒ¢ÈrÀeøKIq1ÝéÝãGàUõ ò”n\H à–µk¬h9d·ãN¤7¡¾…>N©TºÌ|)ÝÝ ºÁ…ŸF÷„ 12Õ¬®®FÎ%>×ÉdÑ/¢WÓ>85§‘Éy É{©)©ý|ë’G„ܹK1úׯ¥T€>ÎS~aú Ö¬\E+3L 0À_|¼½é“åÎN@^344¤¯£K14Þ'O À-žÔŽj÷NNN"Ó¸FGGõ5'ôqº< {@7@d%‘H4þ»<Ž¥û»pE¶å>7!ÓÅ'›3-‘? ’ßš››):Çiç.¤"pvÚC1ú¯_Á¥T€>ÎS×ǹºR¼cëëë3ÀG†‡‡évæÄYrŠÐ}u¡¯£;80ÀwŸ•EŸäåæ!͸F|\ôqŽ322B]&½w_³?ª©±‘âšaÊ ‘-@y Àeúûû½OžbT714’Ó õôi9GGk Y·"ù2QÔ]¢MñÖÀiÎSØÐÇïߦxëš›š¡Ä àáOŸÒÌáCTUVÑÔÝÛwx퉉 º{ê+++‘f\€ú~èãLÓÖÖF±À”%½zÅæO#ó7º?áel,rhVhƒ>.Tß¿{GÖ°¾§}NxyùŸ=|ó6{$§òêó–Èg‘‚ñÏÍ t_´µ¶"ë8KWWÝ™!ŠÓú8OaCÏÊÊ¢û$ËÈÈ@ä_Ø`mƒÆ|nÅmtþ9zøNÿæº]AgŽÓ§NÑ –Ýú l^?õWÅ+-—kªŠ:à;ÐÇÁ<¸rû‘ð¤õû¢m[ÒߧÃQáÀ¾ý”K¬ìÚ-çQîwu-ð*RŽ³ߢüºíÍè}œ§°¡Ó­/qØÍ‘ü˜dççS~t=À£‹AâãéÆë]Z2½ÛÏÈÈÒL³´´´0QÄú8Ó444Ð--Jìý»wì\¼L&[µ|Ý‹òYTú8˜‰DrÜÓKÉÐ;lÙÚÜÜ §±Loo¯¹‰)Ý®NãããÂpŽB¡ {NËÌØdll YÇA&&&ÈӇ¾¾Ž¥ôqžò ;_sÀe ûròø ºs¸¾¾>x•9¤R©©‘1ÅísváµCèžÝƒ¤¥q.]¼È8}œiŽõ ¯­ö›Ù¹òø¸8ºWnnj†E;Pèã`6­--ÖVk}C£ô÷ïá:–‰‰Ž¦û@)ÈÏŒs¼OR>jöøÑ#¤yE½- ¼Jèã<…%}<ü åsµ·ƒƒ<Àqô´u(¦½§Ç1x•i._¼D1dZ¿/âûö"ºGYW-_d``À@Wú8O©ª¬¢¾÷?ëóg®œn1b!wï"€Ê@³gìV«V«Ú‹µRSRà@6‘Ëå6ë¬)>PÂBC㜌é>m-—ZH¥Rd§ +©Õ+VÒ tÐõëp,] ó–ôñ††Ê[‡LL±upœ§ŸÐMû/ÙÙð*Ó466ÒU ®òÚ!Ô7~&ÄÇ#Í4ÝvÙÐÇÙÇuÿÊ¥W™oÇô.-î5é !€Ê@3p?ä¦rèêÕÔÔÀ‡lõ‚â3刻p ·Êd²¥´[a‡?ÅÑOnC}_[[ ÇÒú8Où…µo²µYÒ“@TÐÝÝ°n\ÊN»vÓ}™Çëʆ‰„îŽãµk¬°…\# šAç5E…EÔ£VPPÀè5oÛê@÷‚Ñ1 ¨ ôq0ÌŒL5Ó€Œrp#ËSSŠ½Íì6Ø É9ÎS/h6<<Œ¬ãcccË-–Ñ ñ&[;8–:ÐÇy {úxÈ»tïäË,qÞp–¼Ü<º ÿ0ì¼Êä!D7v‰ ‰¼vÝ2úÄ"ŸE"ÍØ'ðÊFÅqèãì@÷±ûö3wµ9_¾Ð½Z=mžž¤Pèã`:»ÕÏ„ô÷éð$›<àJë.6ÐÕ’gJŠ‹©Ïîø~VHP—Ôˆ=zðŽ¥ôqžÂž>N½Ä CÀeŽ{zÑíI‹Îœ¬199iafN1|;¶ñÚ!Ô.Ë¥£££È46éèè Ûú¸¦ÈÊÊ¢¸ŠŠ †®Öe¯3ÝK=çw9Ôú8øÎׯ_©dÂÁ®p&›<~ôˆâ“¥»»[Hα[¿î“Ww‰vsS²NãtvvêéÓ ®ŽÖl;`èã<å6¿l£­-ÝûÙÔÈ5(éïï'3 ª9=àU6 º~î`U]UÅk‡X[­E…^ãqä(Óâ8ôqÖpز•nàHz0qååt¯S{±VKK ¨ ôqðˆðpZ"Ž5³ Ý­U•UBr΋¨(ê¼½NNÈ:sØÍzd½Žy±L}œ§°ªSoWHìâù ˆ"à>DgN^ÓÖÚJñ©&€=ÔGo­%uµuÈ4vøüé â8ôqÖHÿžnàÈp×ÐÐ@ý:©¿•9áå…èõ>¾ãéáA+ áO6'ê.‹Ýèè(ýfâãâx„z·s \Œ}œ§°ª P?ß­½X«²²ä/‰dddD`?ŠîfÛµèÌ© ìÛO1ˆ†zú$Õùë¡¡!º]:‰9íÜ…4c©TJ}û?ôqc·ò<è^aSc#Ý·ŒZ¿/ª©©Aèú@ß±µYO+âãáOÖ£ø|ùüé“ÀüséâEês<3c“ÎÎNäžF Þ–“Øæ›à[†€>ÎS~aùûN?NýÆÞîà P(KÑÑѺÛqçwÅMO[Çfí:ÿ³çÞ¿{'—Ëyýë¨k~†œaê;4É‚œ×¹pžúèŽLcšË/±#ŽCgâjêG:ÚZ[)^á_ºWèæzqT€>¾C±˜oø“§ð'kµ?ÅçË»´4ù§µ¥…<Ö©Oóœ÷ìEîi„#˜·'&$À· }œ§°­çåæ1qo?zˆ®»ü ³£ã„—×üìµk¬â^òø—§Ç1ºšEoo/2‡}ärùJËåCi·Á–×iii¡»”˜®þ0J~^õ¨AçȵnÝðœ;Gëòºººè6á V\T„¸*@SLLLP£Bï݇Ky»ô÷éÂsÑéS§˜˜é=~ôéÇ2/cc™åÚ5V|ß•Èe ó”_ØÿÊÍ7Q¿½õ´uêëëN.£P(ÂBC•/ÑpÄÝ}xx˜w?³¯¯îëúcGÑ™Sc„ܹKw¤*((àµC(–éün[¶NNN"Ù˜`hhhõŠ•¬‰ãÐÇY&6&†úTª»»›Êµ^¾B¹Ӯ݈8 ôq0YhP¦‚oÞ‚KY£³£ƒbì²²²„ç"êUξïÜBÅj6©®®¦^ârÊ^ÆƽÌ}œ§h@óú wøæMöˆ(7pÞ³w¡1Ý`m380À¯_ú0ìÝÄÎÎBgNÑÕÕE÷mÇÉãÇù>EÓú}Ú,󷃇ØÇ¡³Ìää$Ý3.į\QÿÂ)–,jqX A ƒÿV‡)ÿ³çàRÖÈÍÉ¡»¢BažO:îéÅÄdo¹Å²Þž$! ­¥}XpÊV­X)“Éàaæ€>ÎS4 Ëår«U«™¸ÏÏžñCD9HUeÕš•«T‹©ã¶íããã<ú±tŸaV«× 4ËwwŠÕ]¢Ýß߇̶Ԕ$]=|Ȳ8}œ}"ÂÃéFÐPO_ý×Ò!w)Ÿ¼ÙboXŠ@SÐÕÇìÛ—²FXh(ÅØ}ýúU^jjld¢ 9±]ŽŽ8ýÉ4 …âàW†fìØ<Î4ÐÇyÊ/ùVŠÓYMTN‘ññ£‘¾:1½Ì—›•M7ŸÉä)¤Y²>¦Ó‡axíêêj&Nk’Q‚|2òŸ?}Ò^¬}\ðH¥R 3sºA ¾uKÍK275Ãû3Àe ƒ)èêã+–YÂ¥¬á´sÅØ‘'—PuÞ?€¡)ßÉã'‡Œrñü†b·ÑÖV¡PÀÃŒ}œ§hFŸ˜˜XÅLQT}Ý’’Ä•#D„‡«¯Ñèêuttðâ÷z9J¹3'¯q«Õkp&`:'¼¼:臄§BCCƒ‰¡ûâ8ôq@w1S#c‰D¢ÎsŸîõج³Æ*Ðú8˜‚®>NŒ/ ¾ÓÙÑAQ{Zjj&`_õ÷÷37'DÍ}æxòø1sÓõ¬ÏŸáa¦>ÎS~ÑÔÇÇÅ1tÓ©j[[B«Yärù…€óÙÎƽ==t°y9ŠDâÔkÊÊÌäµC¾~ýÊÐiÍm[¼…‡¥¨·—îèãG"‘P_ú> Síbd2Ùªå+è^LÜË8DÐú8˜‚º> ¯²ÀÍ èÿ¬<ÔߣO·Èg‘HHê¼NJbâ´.*A± ôqž¢1}\¡PØ­ßÀÐmok³~ppÑÕàtó€Ë>º‡€¸ÿ«CïߧüjWˆ½ÔùH¿îmŠ‘u;xˆï>¹|ñs“6´‹Q‰D²y“½¦Äqèãš"øæ-êû T{S•OùXÉòu ƒï ºC–ÓÎ]ð*Ó ™SŒÚyÿa{lbbÂf5C?­ß‘G?Ò’"ïÒÒÚ‡4Õ «±±Nfèã<å ~wúûtæVéÛFGG`ö)/+[Í@ñî¿ð Ûu–|r‰;Ðíÿ®½X‹ï'pÉýhflÂÐèM¼”Sññqºå8¡ó…C=}º¡|¡Â•l°¶¡{ááˆ/ ôqðßÉ m}\ë÷EÕUUp,£^¾B»{Y‚à–››K’“¡¹Y×¼M†~G‡O™™tweÍ°»·ïÀÉì}œ§ü¢Ù¯ßïâÂÜý¿g·Óøø8bÌ&Ñ/¢õ´u˜ˆf}]—øçOŸèþÞÐû÷‘NÜ!?/ûfð,"‚¹ÑÛ÷´²nA‡ÝS;ÐÇE®¬Z±r¡·ß¿{G÷–šš¡à`èã` êú81÷Cnp,sTUVQßZÛÖÚ*×ùxŸfnú§½XëUâ+䧚|HOgHH™² Ö6“““ð3;@ç)ÖÇ›››œ÷ìC˜Y`ddÄûä)æB™Ÿ—ÇåŸÄý0:s ºû"--–ñ½h€\.g´”™Ç£)Ÿ’Œ3ú²ú8÷éêê¢>›Š‹}¹ kضÕîÜ Ad@S0¡ûžß2T*µµYOýe°x²ÝÂÌœ¹à’E‹ccb¥*ó69™¹²*S§[ òóágÖ€>ÎS~ÑøP¯›9Ãvîp”H$ˆ4£Э.2Ûª*¹{\±»»›îóìèá#H*®N7¥SSRøî“’’æºÇ;yüJÿ”‘‘g§=\Ç¡k–s~géFÓÚj­òï¨rsrè~»±áÐР˜ú8ø®2ñ(´03'K¸—:>ÞÞÔƒu!à¼x˜þþ=£“@­ß©Üß[äDG½Ð^¬Åht®\º ?³ ôqž¢y}\*•Z­^Ãèp°Õ~3vã2Ääääõ«×ÕȦ·\®?~?äåÎœŸ?#µ¸Æðð°®Å(ïur€[Îû0zï<àŠ óÐ××GpÇ¡k–Ö–ê;Þ¼~£ä·ïs¦|‚L-SÀÐÇÁ éãSkOœ`¦ËãG˜ˆÔ—ìlQ¹Ñï̦§‚çÎÉård¬ò]¿ÎtP6ÚÚNLLÀÕl}œ§üÂ…‹(ÈÏgZ`]½b%Ç Xó‘²Ò²M¶v,h.¶6ë9ë…BA·):srßÓ>tßú øèèèš•«½ý·mu@úͦµ¥ÅÚj-wÄqèãçÔ‰“tJñÊ|oEy9ÝïÕÓÖéÁ¶ÀÐÇÁÌéãÄÜ‚JH 2»`¢½¤åR ±S$óöuk¬˜ž ruAÞþ©TêuÌ“ép9Umm-¼Í2ÐÇyÊ/¹ŽÀ+W˜L °-—‰$Àߟé·ÿ¿™á-î63ÌÌȤܙó:sr”ÒÒRº±¾|ñ’Üò%;›‰EËt[»Æ /8gPXXÈhIèã|¤¾¾žúsY™BºÇŽzPß}†hæ€>¦`T'FÆF”‰SŸ´ÔT†ê2]».ÎåŒîm¦'„¬mšø¿ ˆQÚÚÚíäôÝ"ÂÃámö>ÎS¸¢OLLPo¸1goå°ÐPD]MÞ¼~ci±Œ5Á…L‰Z[Z8ë ÷Cnt,6ÍqºóS#ca¹táÓ〱aÆÇÈÀ)â^Ʊ°¶>ÎGŽ>B7¦ÛæÿÆæ¦&º¢<™ªqù¡ôq0Óú81²L@™8uHLHdH×ú}y~a dto"zÕþˆ/ÙÙæ¦f,DÁë˜'¼­ ó”_¸s)ÕUUú:º, GÜ£c§j”—•9íÚͲàâãíÍY‡tvvÒm¦A’iÆeb¢£é¦wÜË8¸e||Üný¦‡2ϸ¬|Ã@A211àïÏAeú8G¨¨¨`¹<«Ÿ¯/õƼˆ#à‹6}œ×° ÛboOÖ ð¶ ÎM¸ì£~Óý軺ººèe Ó TÉL}LÁŽ>þGk‹e¹¹¹p¸òÈd2¦;IˆÙÃR©”.bS¯ˆD»Uííí;w8²¦¢|ýú>×ÐÇyÊ/\» oov† ’²×¯^GÌOOOÏ•K—õ´u4¢¶¼Œå¬g Å*ª9׬\…|ã>ÔwïV”— Ã3¬½à\f¾4ýý{±%^bB™érY‡>ÎÈšŸzd‹‹Šæü.êÍcÜBÓ@S°¦O-<ƒ®_G9reèîîvܾƒÑpìÙí?·µµ‘Œü7ÐÕ{òø±ÈÏ€F¿ˆfm&¯£µ»î4 ôqžÂ9}œÍ—™Ä¬­Öææä 椽½ýBÀyvö„ÎiÇ=½¸ìŸŒéþÞû!÷uܧ¦¦†nÜý|}ãÖ^pó>yjxxX )×ßßÄý0Ç•qèãœb·ãNº‘=äê:‡´48h¤o@÷‹JŠ‹>À4ÐÇÁ1õñ)#‹Ü½nÿ]^ed0Ý~\ë÷Eåeep5¡¬´Ì@Wµüßá°­¾¾^„~nmiqvÚÃæPƒôÖ,ÐÇyÊ/¼¦öövÖ^fN=#}¼O÷¢)â4È£ËÇÛ›¡v(Ê×àxC7׃èÌ)N·m§»¥B0:ïøø¸Ãæ-¬Ë-–½yýFØÉ·”•>ÐÇ…ÄçOŸ¨Ï”ª«ªf|KÈÝ»ØÐøôq0ûúøÔpêçë;00ÿÏ`llìBÀyŠyžðò‚·¿óþÝ;ºM¶ºà½~õÚÈȈHÜ+•Jo³¼ÝðfÐ $¶Æ>ÎS~áæe•––²ù2“˜‘¾Aè½û"ï0.“ÉÒRS÷ìe¿Îø [omÓ××Çe_uvtÐîÌéŽñˆ/$&$ÒMøg‚qNgg§åR 6‡ 2d556 /Íjjjv9:òE‡>Î5¨—ª÷ô86cÉgNûÍMVVXú8˜B#úø”†Ü¹;::Š(L‘•½v;E™±!iáOŸ²œÿË-–%&$¾ÜJò›dºµX•kr~)Í ó”_8{e©))ì«´+-—“IóÄÄ„Øò ³£ƒÌÒÈÏç‚Âbmµ¶««‹ã»|›î¯þ”™‰ñˆ/Œ››PŒþk!ù§¤¸˜åœ:ZK.œçøK5åéîîöóõe§µ=ôq¡ò.-zñÜé/¢"ÂÃé~þVû͈`èã` êãSfafþèáC‰D"æ(477vsgÍçQÏŸ#ógs;8˜ýü·Û`›þ>]þ$ëú-ööì»Ôýšpèã<å._Ü“Ç52Y™RÉÅ°—|xx86&Æi×noŸ¾Bæ¾È%—Ëé¾KX½b¥È;–ðŽÀË”»Òååæ É?©)©lžÖü¾ëNðí¡¡!^¯Õoݸi¨§Ï;eú8±[¿n|}¼OO}2Y}Qß•–šŠv€>¾?s¹ðè414 º~½»»[lþoiiñ=íÃf=Og§=Hûqùâ%äÿv!©ä;whæôç>gîòä,ÐÇyÊ/¿¾»·ïhj²bnbz3èFgg§ð¢>44ô:)éèá#zÚ:œÒV\ö:k¶™T*íïïokm­'ÔÕýÈb¢£éþð³güæù:ŒüòCD^/h ¹\N¾³££±±‘¢‡ÓRSéæÀa7÷ù¿‘\WW¹Aøò*…ýÓšßUr²ÎäÝ^òžžž«ì+ã¦FÆ?íу‡ªÝPÍÍÍÄâ©GÉI¯^Q?¨QPP@âE}ûÂza¡6ä>%w+¹géÎ[Ø´[7nR\,ð×dª;5]‡>®q#¬Ç‘£YŸ?‹ÁóÅEEäDz|NŽÜ­Ü? ¬Yü|}5X[5.ö%Ç"™LF&]›lí4åÀÝŽ;±ðª>þøÑ#Ï4ø6ù…û¹xåŠf'+n½÷NgU¾~ýþäé^''Í6ÞüñÆ4ïÉÉIögƯ“’üϞ۹Ñ®NÄ314"?íœßÙW‰¯DÒ H¡PÞ½}ç°›»µÕZ>©øé d·~ƒ×1ÏGÖÔÔp9ÔË)ozÚ:dH)/+ã~Æ–Ÿ<~Bw‰6û^Z·ÆêCz:§ÒÛ@Wo«ýfžGF¶´´`z­æÛA«Õkx1¬ÅÇÅ!^œ…¬až<~L:mm52RÁX°eæKÉáBÀùÔ”ñ”ûà”>þݬV­¹s·¹©IŒxfo·Q#mQÓß¿ÇxþÓ5”÷i &¿™±Iàå+üê*ÔÖÚz3èB5è7§»°ÅdöhSPP|óÖå‹—üýÙ4î”gà¾YZ,sÞ³÷ÒÅ‹i©©Ïä_x‘ßçÎi¥Réðì7BѬmÞdÏåSWš:­ùݶØÛG„‡÷÷÷sÍ3ä’È…mÞ¸Iƒ[uº»»««ª¸œÞ;w8 µ6%;D¿ˆæþ Fm”Ëä&©)©[¶bå&6Ó×Ñ=}êÔׯ_¡kÖÈÝ÷ôñ“Vþ¿*HˆwÝ@ƒ;´‚oÞ®$çý4›ùZ¿/"Ó¿QQƒÞÚE®L±ö:9±_Or†pÙ‡ãß)*,:çwvµÈÔ!™¡ž¾ß™3m­­Ðǹ.²LßaáöÜûwï8»½¢··—\ÞÕÀÀm[¸¿y–,ŒËJYÝã©P(îÞ¾ÃÍMô,I‰ k×…'FˆùY¸ÛqggG7CséÂ.¼:äêûRãuWÈË £Ù!ÈÖf}oO¹ŽëãÿúïÛ/˜æ«,399¹b™%Çãû,"‘âÝÝÝÎ{öb&f#©{!!ÂîŽÃq}ü»Ù¬³¼|%++‹G*Yh‘rܶ]ãâÁ®Õ„fïO…¸ì‹Œx¦A±lmmmäzÈUqDIð8r; ¦¨¬¬$Ëa<»…aºK´ÃBC52ù…GI3è×&Ž»ƒoÞÊÈÈÔ g†‡‡óóò"ÂýOžâò>ñÙævðËû:'&&Øl’ÎYsvÚ3::*˜'b|\œh_xLuWQ^ÎQ‰üâEŽx‰,Ò·ï¸{ûNAAkJòEäëBîÜ% ¯‰m²µû>ðòBŸjbÜÜ܌ٿ „?yÊåÈ.55þ'®QSSÃý×*0vìˆûaö‹BŸgí¹Õ~óå‹—RSR¸£N¯öñÇÛÁÁ\öépÄiÄcBZò°™µrª@„­ÍúK.¤¥¦²_/”|#ù^òíÔÛž«]œö´\.G®~ûOÛmHÂ3¼þù…_©?ä7ƒGžë­mNxy……†fdd´µµ1÷º£¿¿¿¨°(>.îfÐ#îîV«V󱼑±a\ìKöSÈÓÃcÍ”ísvÆ3•,¸ 9rÁÌML¹Z³/øæ-®¹Ë@WÏi×î«o^¿©¯¯§(;«©±ñmr2ùpòìwݜǷmŸ~^•/úø”D>µç,ˆ±±1sS3Ά5ôÞ}ĈS´µ¶j¶Ž*ŒkFfÎÐǹiSM†üý£ž?Ïúü¹¹¹™Íÿd¬ÈÎÊ~uùâ%ç={-ÌÌ9袵k¬z{{1°«FB|<5G­ßÙ¬³>yüÄ“Çsss™ˆoOOOnNù|ò-ë­m¸©´ÜFŠNñèÁC<©…j'‡>ÎË‘zÎCdì>xÀõì?2~=ŒLKM%ƒxEEEKKËÀÀÀÈÈÈÄÄÄôyYÄ õõõ‘ÿ ¼¬ŒLtÞ&'G¿ˆ¾{ûŽŸ¯ï—}vë7™}—££Fªé‘9F™év/$„÷+ù¶6cC„rúÖ`Înõ ò”Ë/óÈ“eƒµû!·K.$·zÅÊÝŽ;==<Èd&ôÞý¸Ø—ïß½ËÎÊ.--mhhèìè$‹P2˜!¦“ÿw||œÌmzzzÈR´®¶®¨°(##ãuRI²½pž|¬ã¶í+–Yr¿€çT Oî²ç_²³¹/>+tزõ¸§™‡?yüøÍë7$á§$rMOõ)É…üsòoÉC¦ú)oßNÍ὎y’Ïáþº’,Xâã‘œS|HOG'LaÛËØXèãB©4•Ï]m¨§ÿôñÔ252Æ3Ýôut;;;yýP$SÄq†E„‡s6^Éo’9«+¹i…¿‡.ž¿0{ìå—>N í:U@"‘psÖtý:¢Ãµ=(x†Âf™?“Y4ôqAšöb-AžÂ\i¹¼…ÿ­M¹@mmí*AtxFž“éÜ—ìl¤å###8ñ&üóñ¦flö}ü#5Œ5ss=Ø¡¹‚=BfÛ  þ>;;:PYeÎý2\n¨UXXÈåj‚4­ß=zøpÎpðNßåèˆõ€ p­ƒËÔ ZÌá›lí0`Âæ´§Ÿ@‡ñÅÖ¬\…ž%éïïß³Û y¥q³Û`‹ÄžgÏGÂø»ùï^Ô{0RóÃ,-–¥¦¤h6a6oA f›ÕªÕüÈX‰Îi\\kK T6wšÌ³çšwú8±®®., T˜2èêq*Žþþˆ §hjlÄ€ û‘ípØ}Æ ±»»C:]d2Ùå‹—]´cG=Ðiv«±_Væ¸}ôq¥Ëåׯ^CÉ!ŽWȺxþ›g"ædll dü-±B& ßœÆý–wR©µqX0[›õMó¶lå£>þ69KàÔÊ–Ì P–kÄžĘ ›§ Çøø¸Àr~hh‘˜9íÜ%ÈZ@!éÕ+NõœœòèÁC¤ß êëë‘⹦7n„>þRSR…TŽ\Hæì´§®¶Ž IRSSƒpüÈrssyzïoÞ¸ á›Ó|¼½yÁȈgºK´/†ÌÓãç;Mø¨  ±°FèììäÎívêÄID„kÜ ° ›Çç}ÛÊG¤R)Â*$ó=í3£é( NsSÓ{{$›G½KŠ‹‘x³y›œŒô544@_ííí»w"o8U÷--5•;RŸ üÈÞ¥¥ñôÆ'i†ðÍiî‡ÜøÄŠòòµk¬2º¦»D[ÉZ±|Ôǯ\Áª@5üÎœáBµ~_T_W‡pp€sç0xÂæ±’’᥽¾Ž."+Œó ?골399xù Nð³`Ç=½4~ Ÿ³<‹ˆ@†ˆhÂÖ[¢_s‡(Š{!!:ZK=š5sS³'³vBIŠ‹ŠšÙÇxzׯƒ®úó8r”Gq={ÆQ£evl««ª”t>õñ k×±*P––íÅZàa7wÄ‚ƒ\<ã'l«(/^Úc&)[f¾47'c8Ë|þôi¥år¤Cfbh”˜€4ƒ>›²ò²2èãªPVZ¶ÑÖ ¤3ÔÓ¿ÌÍ—œm­­ð<»¾9íBÀyÞE3ããÇË,;5·å^¾xiA%bù¨‡?}ŠUÊœ<~»PÁœ„Þ»Q6ñ·]Í<¸rCdym»w¢§¦ «þ³gü°‘œº¹<„^ô?åÍë×HÌ@ ÿ™Lv/$DO[iÄšèê^¾ÒÛÓÃåÄ052F¤æ¬Ã •Jyz³_8Îiq±/y:Ïö?{ólÕlÕŠ•9_¾,Ôç|ÔÇóró°*P™ºÚ:ÍÞbÎN{nòñà ¤°yŽ‡ 2í†= âŸ•–Ë×[Û OØ4­%a¡¡ …£·f!“O«U«‘´FÚ×IIH*e@{9ñØRg ¿õ†illtÚ¹ ÉÄžñëW¯õõõq?%Ž{z!^³Íe¯3ó³%‹óz“Waa¡½ÝFÄqAKD2©àmÞéã¦FÆ“““X¨Ãww F0;+!à&###¨Å û‘<~ Ë“©×›&¦Á7oñhÏÍÍEÔf[jJ*op²Yn± Aœy(Ïõ ߇n¹\þ,"ÂÌØÑü©írt¬«U½Õ!ïôñ+—.c= &åeeš ŸÃæ-ð?—ñ>y ƒ*lNSá|_ØboOÑ?ƒΣ!£§–†= KŒØ\£µ¥å°›;RTÛ¹Ãï{T èúu$¬¨°ú85&&&ÈCÔÄЉEËlÖ®{ÅÇ¢¸"|ÓÍqû¾ßàÑQ/Ç馽X«ª²J£÷ÐÐPàå+ºK´Ö9ÍÒbY|\œšNæ—>nfl‹ãJÜgŸ³‹F"ø.- Îç2ÍÍÍra³mÏn'§}jJŠšþÙj¿yæ­ÔÔtòø‰%‹#yèÚa7÷¶ÖVŒÕ\&ëóçÍ7!W•´5+W%½z…´Q ²(€Ê'†aŸÍ¤úE$7Oÿõ«× tõa*›Öï‹ÈŠ:ý}:Ó ­­ÍØÀ¡œ2=mu¶r‡½NNˆæw ¾yK`£7Yùx{k/ÖBp¿™ †Þ»Oå%%¿ôñ¸—qß òóòØßkxžû< à ›nFúÍÍÍxe8O‰³â¢¹·¶544xó„JNŶ;8`ˆæ o^¿±Y»y;ß6—¥‘ÏP3PM^ÆÆ"—„½æe¹lì/¢ºúúú®B%W¡” ñÛׯ_¹99(Ž65›ÿî0îëÌÀ¦ìèá#BíST__ïéq ‹L=mÀËW(¶â‘>tí:–ٹÑå&&$Àí¼àäñxžÂ¾O322Ÿó===kV®RÍE‘Ï"çÿð¦ÆFÿ³ç°úPÙ6oÜÄëj¢E&“ÅÆÄX­^ƒž)­˜š…Þ¿¯Zß 0›K. ©„ZM« ?ŸåtúE„·Pooïíà०fȹùmÉ¢Åûœ]^'% )ÈDßHß@ä›ÀZc“›ÚaËV‘ß°¾§}_±±±ÑÇÛ[œe=ÉÌÿ:::躔/úxà•+XÐ%3#“Í®^±åbù‚B¡8wÓ`˜‰¡(D’öÍÍÍ •ÈÉB)êùs%?¿¯¯,?-ÌÌ‘WÊÛ‡m?|À˜Ìkärù›×o¨Tù€‘¹PDx8«ÔrœAAZ¿/B‚ ÉŒ ?úÄ~.ý"Ú»ˆ LÑ/¢7XÛ ùf›Ýú Ãtuu vÜÔäì´GœÁݹÃQeUfoR¾yKœÛs,—Z$&$Šgôîèè¸(žzsËÌ—Þ d™Ü×ÇÉZ"ýý{Lý™`ó&öÖ«?Ýb ¸ÆÛää•–Ë1%­pÙ'¶BÏýýý‡\•íTd³v]aa¡ “Urgíur‚”3é.Ñ>yüDii)Æa!‘•íºÿ€hO‚:lÞò:)I.—#"ããG²dÀø‰ôquÉÍÍ%Ï`œz›’ÅïÞ¾S[[+žÐ{óÉ^r]½£‡dee ;¦]]]Á·n­[c%’–[¶>Œç=‰DñLØï8·ØÛÇÆÄLLL0çFÎêãÚ‹µv9:Æždô狜ԔTÖÞñ`·™ÚJ²Ãaj[‰jÏ8Y‰¹Ðóûwï¶Úožÿ­-™~¨y ¦¹¹ùÖ›*uªÙ¬³½¿··ïPikm½tƒÌ D’Ò†zúgÏøUTT ô,@– /cc·mǤ…§fjd|úÔ©µô€>ζÔò"*Š¬Äö>Ÿ Ûî‡ÜkhhíHZXXH¢Þ?à°›»óž½Ä!mmym[¶’B~ŽÿÙsÏ##ÉX‘œŸòõë×Ô””»·ïxó<à²oçÇÍ7ñ:¦äúw;î<äêzòøñÐ{÷?~øÐÓÓƒ¡ûÛ: zŸ<%¤Æ&†FÎWUV±à½ÆÆF.¤÷VûÍN»v“ô>ããþäivVöÐÐr›ö»¸°ßȈgp5¯éëëËÈÈ =uâ$¹OÉݺÅÞžï3%Ø&[;2ã%ÓÅ#îî—/^Š‰)--E¤)š#ÂÃÉì‚Ì!ÉŠL#>rçn^nÝ/*(( susq—ý\f¾4ÀßÆÅÃäädò›d·ƒ‡„Z2Që÷EdÐx%‘HnLZÈJùaØßÓ>S“2Œã¡ÏÙÈÕÀÀø¸¸Šòr.°€>>“ÎŽ²8wܶ]ØB¹™±‰×1ÏW‰¯(öyM122÷2nŸ³‹öb-þ(vÝ 1!;mñ —Ë ®_½&ª†ó«–¯¸|ñR~^žP{˃Ÿ280ý"Úi×nÁløµ·Ûø0ìA{{;‚ >þC:;;Éx}Äý°`ªÜ’âvðГÇÙÙ–ìÓ××G†n×ýô´uørôÒÓÃãuRö˜"§©±12âÙa7wAöY1ÐÕ;ಬFëëêk0}öž˜àuÌ“i¯£µÄyÏÞˆðp±õl@x@ÿ92™,?/ïNðm2ðêéó«vŠÝú ¾§}¢_DWWWãå<@<Œ¥¿!༵ÕZ×vزõúÕkŸ23±[3Ëå%%%O?öôðàu³\sS³Ãnî>,).žœœDdÁüÂK^nÞÝÛwö:9q¹?Ü’E‹íí6^ºp!-5\ ÐÇyj£­-×jfèê9lÙzöŒßóÈÈ‚‚ Ö@hoo•øŠŒvë7h꧱ánÇ—¯¤¿OFP $i©©·ƒƒÝZ½b%g ’ [µ|Å}ûƒoÞ"Œµ@e&&&òóòÂBC==<Ö®±ÒxΛ›špÙw3èƇôt´É@@WwÔ®¨¨ˆ‹ º~ÝãÈQ{»¬m0771%_çæz0ðò•QQÙYÙ(t?ell¬   2âÙÙ3~Û:È©»DÛfõ!W×kWß¼~ÓÔØÏ€ ÃÃÃ%Åů_Ýö:æ¹Õ~ó2ó¥, ˆ:ZK¬V­Þëää{Ú'äÎÝ×IId]<::Šè&Ìùò%"<<ÀßßyÏÞUËW0šð¦FÆd™à}òTè½ûïÒÒð¦1}œ>½==drðñÇèÑd®àö™µ¸î?°s‡ãF[ÛU+V.553142ÐÕû¾ý|ɢźK´ô ÌML-—Z¬]ceo·‘ü÷\ö;êA>L}"#ž½yýæKvvCCf@‹¡¡¡ò²²Ô””ð'O¯\9yü{ÉR“ Ådµi¨§OÆç©]çd"®¯£Kp2Œ“y¹µÕZ2u>äêêãí}500,44îe\nnngG¼ 6™˜˜hii!ó²f$+Ç»·ï\8OÖ¡dVCÖ•du95±™Z‡~ŸÛL_’Nþ­¥Å2ò_’u+™ä8ïÙëéáqöŒßõ«×Bï߉ÉÈÈ KÝžž”îšell¬¡¡!çË—W‰¯È$üâù '¼¼\÷pܶ}ƒµÍŠe–æ&¦$ŸÉÔýû4~ºäB¦ñ[¶îsv!~Îï,¹_¦Ò»ª²j``î@„@¯s?ú81}€>@Œ@ F #ÐLjèãÄôqbú81}€>@Œ@ F #ÐLjèãÄôqbú81}€>@Œ@ F #ÐLjèãÄôqbú81}€>@Œ@ F #ÐLjèãÄôqbú81}€>@Œ@ F #ÿ/÷ùîD¿'IEND®B`‚cadvisor-0.25.0/machine/000077500000000000000000000000001306035727200150215ustar00rootroot00000000000000cadvisor-0.25.0/machine/info.go000066400000000000000000000107001306035727200163010ustar00rootroot00000000000000// 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 machine import ( "bytes" "flag" "io/ioutil" "path/filepath" "strings" "syscall" "github.com/google/cadvisor/fs" info "github.com/google/cadvisor/info/v1" "github.com/google/cadvisor/utils/cloudinfo" "github.com/google/cadvisor/utils/sysfs" "github.com/google/cadvisor/utils/sysinfo" "github.com/golang/glog" ) var machineIdFilePath = flag.String("machine_id_file", "/etc/machine-id,/var/lib/dbus/machine-id", "Comma-separated list of files to check for machine-id. Use the first one that exists.") var bootIdFilePath = flag.String("boot_id_file", "/proc/sys/kernel/random/boot_id", "Comma-separated list of files to check for boot-id. Use the first one that exists.") func getInfoFromFiles(filePaths string) string { if len(filePaths) == 0 { return "" } for _, file := range strings.Split(filePaths, ",") { id, err := ioutil.ReadFile(file) if err == nil { return strings.TrimSpace(string(id)) } } glog.Infof("Couldn't collect info from any of the files in %q", filePaths) return "" } func Info(sysFs sysfs.SysFs, fsInfo fs.FsInfo, inHostNamespace bool) (*info.MachineInfo, error) { rootFs := "/" if !inHostNamespace { rootFs = "/rootfs" } cpuinfo, err := ioutil.ReadFile(filepath.Join(rootFs, "/proc/cpuinfo")) clockSpeed, err := GetClockSpeed(cpuinfo) if err != nil { return nil, err } memoryCapacity, err := GetMachineMemoryCapacity() if err != nil { return nil, err } filesystems, err := fsInfo.GetGlobalFsInfo() if err != nil { glog.Errorf("Failed to get global filesystem information: %v", err) } diskMap, err := sysinfo.GetBlockDeviceInfo(sysFs) if err != nil { glog.Errorf("Failed to get disk map: %v", err) } netDevices, err := sysinfo.GetNetworkDevices(sysFs) if err != nil { glog.Errorf("Failed to get network devices: %v", err) } topology, numCores, err := GetTopology(sysFs, string(cpuinfo)) if err != nil { glog.Errorf("Failed to get topology information: %v", err) } systemUUID, err := sysinfo.GetSystemUUID(sysFs) if err != nil { glog.Errorf("Failed to get system UUID: %v", err) } realCloudInfo := cloudinfo.NewRealCloudInfo() cloudProvider := realCloudInfo.GetCloudProvider() instanceType := realCloudInfo.GetInstanceType() instanceID := realCloudInfo.GetInstanceID() machineInfo := &info.MachineInfo{ NumCores: numCores, CpuFrequency: clockSpeed, MemoryCapacity: memoryCapacity, DiskMap: diskMap, NetworkDevices: netDevices, Topology: topology, MachineID: getInfoFromFiles(filepath.Join(rootFs, *machineIdFilePath)), SystemUUID: systemUUID, BootID: getInfoFromFiles(filepath.Join(rootFs, *bootIdFilePath)), CloudProvider: cloudProvider, InstanceType: instanceType, InstanceID: instanceID, } for i := range filesystems { fs := filesystems[i] inodes := uint64(0) if fs.Inodes != nil { inodes = *fs.Inodes } machineInfo.Filesystems = append(machineInfo.Filesystems, info.FsInfo{Device: fs.Device, Type: fs.Type.String(), Capacity: fs.Capacity, Inodes: inodes, HasInodes: fs.Inodes != nil}) } return machineInfo, nil } func ContainerOsVersion() 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 KernelVersion() 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) } cadvisor-0.25.0/machine/machine.go000066400000000000000000000177371306035727200167730ustar00rootroot00000000000000// Copyright 2015 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. // The machine package contains functions that extract machine-level specs. package machine import ( "fmt" "io/ioutil" "regexp" "strconv" "strings" // s390/s390x changes "runtime" "syscall" info "github.com/google/cadvisor/info/v1" "github.com/google/cadvisor/utils" "github.com/google/cadvisor/utils/sysfs" "github.com/google/cadvisor/utils/sysinfo" "github.com/golang/glog" ) var ( cpuRegExp = regexp.MustCompile(`^processor\s*:\s*([0-9]+)$`) coreRegExp = regexp.MustCompile(`^core id\s*:\s*([0-9]+)$`) nodeRegExp = regexp.MustCompile(`^physical id\s*:\s*([0-9]+)$`) // Power systems have a different format so cater for both cpuClockSpeedMHz = regexp.MustCompile(`(?:cpu MHz|clock)\s*:\s*([0-9]+\.[0-9]+)(?:MHz)?`) memoryCapacityRegexp = regexp.MustCompile(`MemTotal:\s*([0-9]+) kB`) swapCapacityRegexp = regexp.MustCompile(`SwapTotal:\s*([0-9]+) kB`) ) const maxFreqFile = "/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq" // GetClockSpeed returns the CPU clock speed, given a []byte formatted as the /proc/cpuinfo file. func GetClockSpeed(procInfo []byte) (uint64, error) { // s390/s390x, aarch64 and arm32 changes if isSystemZ() || isAArch64() || isArm32() { return 0, nil } // First look through sys to find a max supported cpu frequency. if utils.FileExists(maxFreqFile) { val, err := ioutil.ReadFile(maxFreqFile) if err != nil { return 0, err } var maxFreq uint64 n, err := fmt.Sscanf(string(val), "%d", &maxFreq) if err != nil || n != 1 { return 0, fmt.Errorf("could not parse frequency %q", val) } return maxFreq, nil } // Fall back to /proc/cpuinfo matches := cpuClockSpeedMHz.FindSubmatch(procInfo) if len(matches) != 2 { return 0, fmt.Errorf("could not detect clock speed from output: %q", string(procInfo)) } speed, err := strconv.ParseFloat(string(matches[1]), 64) if err != nil { return 0, err } // Convert to kHz return uint64(speed * 1000), nil } // GetMachineMemoryCapacity returns the machine's total memory from /proc/meminfo. // Returns the total memory capacity as an uint64 (number of bytes). func GetMachineMemoryCapacity() (uint64, error) { out, err := ioutil.ReadFile("/proc/meminfo") if err != nil { return 0, err } memoryCapacity, err := parseCapacity(out, memoryCapacityRegexp) if err != nil { return 0, err } return memoryCapacity, err } // GetMachineSwapCapacity returns the machine's total swap from /proc/meminfo. // Returns the total swap capacity as an uint64 (number of bytes). func GetMachineSwapCapacity() (uint64, error) { out, err := ioutil.ReadFile("/proc/meminfo") if err != nil { return 0, err } swapCapacity, err := parseCapacity(out, swapCapacityRegexp) if err != nil { return 0, err } return swapCapacity, err } // parseCapacity matches a Regexp in a []byte, returning the resulting value in bytes. // Assumes that the value matched by the Regexp is in KB. func parseCapacity(b []byte, r *regexp.Regexp) (uint64, error) { matches := r.FindSubmatch(b) if len(matches) != 2 { return 0, fmt.Errorf("failed to match regexp in output: %q", string(b)) } m, err := strconv.ParseUint(string(matches[1]), 10, 64) if err != nil { return 0, err } // Convert to bytes. return m * 1024, err } func GetTopology(sysFs sysfs.SysFs, cpuinfo string) ([]info.Node, int, error) { nodes := []info.Node{} // s390/s390x changes if true == isSystemZ() { return nodes, getNumCores(), nil } numCores := 0 lastThread := -1 lastCore := -1 lastNode := -1 for _, line := range strings.Split(cpuinfo, "\n") { if line == "" { continue } ok, val, err := extractValue(line, cpuRegExp) if err != nil { return nil, -1, fmt.Errorf("could not parse cpu info from %q: %v", line, err) } if ok { thread := val numCores++ if lastThread != -1 { // New cpu section. Save last one. nodeIdx, err := addNode(&nodes, lastNode) if err != nil { return nil, -1, fmt.Errorf("failed to add node %d: %v", lastNode, err) } nodes[nodeIdx].AddThread(lastThread, lastCore) lastCore = -1 lastNode = -1 } lastThread = thread continue } ok, val, err = extractValue(line, coreRegExp) if err != nil { return nil, -1, fmt.Errorf("could not parse core info from %q: %v", line, err) } if ok { lastCore = val continue } ok, val, err = extractValue(line, nodeRegExp) if err != nil { return nil, -1, fmt.Errorf("could not parse node info from %q: %v", line, err) } if ok { lastNode = val continue } } nodeIdx, err := addNode(&nodes, lastNode) if err != nil { return nil, -1, fmt.Errorf("failed to add node %d: %v", lastNode, err) } nodes[nodeIdx].AddThread(lastThread, lastCore) if numCores < 1 { return nil, numCores, fmt.Errorf("could not detect any cores") } for idx, node := range nodes { caches, err := sysinfo.GetCacheInfo(sysFs, node.Cores[0].Threads[0]) if err != nil { glog.Errorf("failed to get cache information for node %d: %v", node.Id, err) continue } numThreadsPerCore := len(node.Cores[0].Threads) numThreadsPerNode := len(node.Cores) * numThreadsPerCore for _, cache := range caches { c := info.Cache{ Size: cache.Size, Level: cache.Level, Type: cache.Type, } if cache.Cpus == numThreadsPerNode && cache.Level > 2 { // Add a node-level cache. nodes[idx].AddNodeCache(c) } else if cache.Cpus == numThreadsPerCore { // Add to each core. nodes[idx].AddPerCoreCache(c) } // Ignore unknown caches. } } return nodes, numCores, nil } func extractValue(s string, r *regexp.Regexp) (bool, int, error) { matches := r.FindSubmatch([]byte(s)) if len(matches) == 2 { val, err := strconv.ParseInt(string(matches[1]), 10, 32) if err != nil { return false, -1, err } return true, int(val), nil } return false, -1, nil } func findNode(nodes []info.Node, id int) (bool, int) { for i, n := range nodes { if n.Id == id { return true, i } } return false, -1 } func addNode(nodes *[]info.Node, id int) (int, error) { var idx int if id == -1 { // Some VMs don't fill topology data. Export single package. id = 0 } ok, idx := findNode(*nodes, id) if !ok { // New node node := info.Node{Id: id} // Add per-node memory information. meminfo := fmt.Sprintf("/sys/devices/system/node/node%d/meminfo", id) out, err := ioutil.ReadFile(meminfo) // Ignore if per-node info is not available. if err == nil { m, err := parseCapacity(out, memoryCapacityRegexp) if err != nil { return -1, err } node.Memory = uint64(m) } *nodes = append(*nodes, node) idx = len(*nodes) - 1 } return idx, nil } // s390/s390x changes func getMachineArch() (string, error) { uname := syscall.Utsname{} err := syscall.Uname(&uname) if err != nil { return "", err } var arch string for _, val := range uname.Machine { arch += string(int(val)) } return arch, nil } // arm32 chanes func isArm32() bool { arch, err := getMachineArch() if err == nil { return strings.Contains(arch, "arm") } return false } // aarch64 changes func isAArch64() bool { arch, err := getMachineArch() if err == nil { return strings.Contains(arch, "aarch64") } return false } // s390/s390x changes func isSystemZ() bool { arch, err := getMachineArch() if err == nil { return strings.Contains(arch, "390") } return false } // s390/s390x changes func getNumCores() int { maxProcs := runtime.GOMAXPROCS(0) numCPU := runtime.NumCPU() if maxProcs < numCPU { return maxProcs } return numCPU } cadvisor-0.25.0/machine/testdata/000077500000000000000000000000001306035727200166325ustar00rootroot00000000000000cadvisor-0.25.0/machine/testdata/cpuinfo000066400000000000000000000102611306035727200202200ustar00rootroot00000000000000processor : 0 cpu family : 6 stepping : 2 microcode : 0x10 cpu MHz : 1596.000 cache size : 12288 KB physical id : 0 siblings : 6 core id : 0 cpu cores : 6 apicid : 0 initial apicid : 0 fpu : yes fpu_exception : yes cpuid level : 11 wp : yes bogomips : 5333.60 clflush size : 64 cache_alignment : 64 address sizes : 40 bits physical, 48 bits virtual processor : 1 cpu family : 6 stepping : 2 microcode : 0x10 cpu MHz : 1596.000 cache size : 12288 KB physical id : 0 siblings : 6 core id : 1 cpu cores : 6 apicid : 2 initial apicid : 2 fpu : yes fpu_exception : yes cpuid level : 11 wp : yes bogomips : 5333.60 clflush size : 64 cache_alignment : 64 address sizes : 40 bits physical, 48 bits virtual processor : 2 cpu family : 6 stepping : 2 microcode : 0x10 cpu MHz : 1596.000 cache size : 12288 KB physical id : 0 siblings : 6 core id : 2 cpu cores : 6 apicid : 4 initial apicid : 4 fpu : yes fpu_exception : yes cpuid level : 11 wp : yes bogomips : 5333.60 clflush size : 64 cache_alignment : 64 address sizes : 40 bits physical, 48 bits virtual processor : 3 cpu family : 6 stepping : 2 microcode : 0x10 cpu MHz : 1596.000 cache size : 12288 KB physical id : 1 siblings : 6 core id : 3 cpu cores : 6 apicid : 16 initial apicid : 16 fpu : yes fpu_exception : yes cpuid level : 11 wp : yes bogomips : 5333.60 clflush size : 64 cache_alignment : 64 address sizes : 40 bits physical, 48 bits virtual processor : 4 cpu family : 6 stepping : 2 microcode : 0x10 cpu MHz : 1596.000 cache size : 12288 KB physical id : 1 siblings : 6 core id : 4 cpu cores : 6 apicid : 18 initial apicid : 18 fpu : yes fpu_exception : yes cpuid level : 11 wp : yes bogomips : 5333.60 clflush size : 64 cache_alignment : 64 address sizes : 40 bits physical, 48 bits virtual processor : 5 cpu family : 6 stepping : 2 microcode : 0x10 cpu MHz : 1596.000 cache size : 12288 KB physical id : 1 siblings : 6 core id : 5 cpu cores : 6 apicid : 20 initial apicid : 20 fpu : yes fpu_exception : yes cpuid level : 11 wp : yes bogomips : 5333.60 clflush size : 64 cache_alignment : 64 address sizes : 40 bits physical, 48 bits virtual processor : 6 cpu family : 6 stepping : 2 microcode : 0x10 cpu MHz : 2661.000 cache size : 12288 KB physical id : 0 siblings : 6 core id : 0 cpu cores : 6 apicid : 1 initial apicid : 1 fpu : yes fpu_exception : yes cpuid level : 11 wp : yes bogomips : 5333.60 clflush size : 64 cache_alignment : 64 address sizes : 40 bits physical, 48 bits virtual processor : 7 cpu family : 6 stepping : 2 microcode : 0x10 cpu MHz : 2661.000 cache size : 12288 KB physical id : 0 siblings : 6 core id : 1 cpu cores : 6 apicid : 3 initial apicid : 3 fpu : yes fpu_exception : yes cpuid level : 11 wp : yes bogomips : 5333.60 clflush size : 64 cache_alignment : 64 address sizes : 40 bits physical, 48 bits virtual processor : 8 cpu family : 6 stepping : 2 microcode : 0x10 cpu MHz : 1596.000 cache size : 12288 KB physical id : 0 siblings : 6 core id : 2 cpu cores : 6 apicid : 5 initial apicid : 5 fpu : yes fpu_exception : yes cpuid level : 11 wp : yes bogomips : 5333.60 clflush size : 64 cache_alignment : 64 address sizes : 40 bits physical, 48 bits virtual processor : 9 cpu family : 6 stepping : 2 microcode : 0x10 cpu MHz : 2661.000 cache size : 12288 KB physical id : 1 siblings : 6 core id : 3 cpu cores : 6 apicid : 17 initial apicid : 17 fpu : yes fpu_exception : yes cpuid level : 11 wp : yes bogomips : 5333.60 clflush size : 64 cache_alignment : 64 address sizes : 40 bits physical, 48 bits virtual processor : 10 cpu family : 6 stepping : 2 microcode : 0x10 cpu MHz : 1596.000 cache size : 12288 KB physical id : 1 siblings : 6 core id : 4 cpu cores : 6 apicid : 19 initial apicid : 19 fpu : yes fpu_exception : yes cpuid level : 11 wp : yes bogomips : 5333.60 clflush size : 64 cache_alignment : 64 address sizes : 40 bits physical, 48 bits virtual processor : 11 cpu family : 6 stepping : 2 microcode : 0x10 cpu MHz : 2661.000 cache size : 12288 KB physical id : 1 siblings : 6 core id : 5 cpu cores : 6 apicid : 21 initial apicid : 21 fpu : yes fpu_exception : yes cpuid level : 11 wp : yes bogomips : 5333.60 clflush size : 64 cache_alignment : 64 address sizes : 40 bits physical, 48 bits virtual cadvisor-0.25.0/machine/topology_test.go000066400000000000000000000063671306035727200202770ustar00rootroot00000000000000// 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 machine import ( "io/ioutil" "reflect" "testing" info "github.com/google/cadvisor/info/v1" "github.com/google/cadvisor/utils/sysfs" "github.com/google/cadvisor/utils/sysfs/fakesysfs" ) func TestTopology(t *testing.T) { testfile := "./testdata/cpuinfo" testcpuinfo, err := ioutil.ReadFile(testfile) if err != nil { t.Fatalf("unable to read input test file %s", testfile) } sysFs := &fakesysfs.FakeSysFs{} c := sysfs.CacheInfo{ Size: 32 * 1024, Type: "unified", Level: 1, Cpus: 2, } sysFs.SetCacheInfo(c) topology, numCores, err := GetTopology(sysFs, string(testcpuinfo)) if err != nil { t.Errorf("failed to get topology for sample cpuinfo %s: %v", string(testcpuinfo), err) } if numCores != 12 { t.Errorf("Expected 12 cores, found %d", numCores) } expected_topology := []info.Node{} numNodes := 2 numCoresPerNode := 3 numThreads := 2 cache := info.Cache{ Size: 32 * 1024, Type: "unified", Level: 1, } for i := 0; i < numNodes; i++ { node := info.Node{Id: i} // Copy over Memory from result. TODO(rjnagal): Use memory from fake. node.Memory = topology[i].Memory for j := 0; j < numCoresPerNode; j++ { core := info.Core{Id: i*numCoresPerNode + j} core.Caches = append(core.Caches, cache) for k := 0; k < numThreads; k++ { core.Threads = append(core.Threads, k*numCoresPerNode*numNodes+core.Id) } node.Cores = append(node.Cores, core) } expected_topology = append(expected_topology, node) } if !reflect.DeepEqual(topology, expected_topology) { t.Errorf("Expected topology %+v, got %+v", expected_topology, topology) } } func TestTopologyWithSimpleCpuinfo(t *testing.T) { sysFs := &fakesysfs.FakeSysFs{} c := sysfs.CacheInfo{ Size: 32 * 1024, Type: "unified", Level: 1, Cpus: 1, } sysFs.SetCacheInfo(c) topology, numCores, err := GetTopology(sysFs, "processor\t: 0\n") if err != nil { t.Errorf("Expected cpuinfo with no topology data to succeed.") } node := info.Node{Id: 0} core := info.Core{Id: 0} core.Threads = append(core.Threads, 0) cache := info.Cache{ Size: 32 * 1024, Type: "unified", Level: 1, } core.Caches = append(core.Caches, cache) node.Cores = append(node.Cores, core) // Copy over Memory from result. TODO(rjnagal): Use memory from fake. node.Memory = topology[0].Memory expected := []info.Node{node} if !reflect.DeepEqual(topology, expected) { t.Errorf("Expected topology %+v, got %+v", expected, topology) } if numCores != 1 { t.Errorf("Expected 1 core, found %d", numCores) } } func TestTopologyEmptyCpuinfo(t *testing.T) { _, _, err := GetTopology(&fakesysfs.FakeSysFs{}, "") if err == nil { t.Errorf("Expected empty cpuinfo to fail.") } } cadvisor-0.25.0/manager/000077500000000000000000000000001306035727200150275ustar00rootroot00000000000000cadvisor-0.25.0/manager/container.go000066400000000000000000000433141306035727200173450ustar00rootroot00000000000000// 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 ( "flag" "fmt" "io/ioutil" "math" "math/rand" "os/exec" "path" "regexp" "sort" "strconv" "strings" "sync" "time" "github.com/google/cadvisor/cache/memory" "github.com/google/cadvisor/collector" "github.com/google/cadvisor/container" info "github.com/google/cadvisor/info/v1" "github.com/google/cadvisor/info/v2" "github.com/google/cadvisor/summary" "github.com/google/cadvisor/utils/cpuload" units "github.com/docker/go-units" "github.com/golang/glog" ) // Housekeeping interval. var enableLoadReader = flag.Bool("enable_load_reader", false, "Whether to enable cpu load reader") var HousekeepingInterval = flag.Duration("housekeeping_interval", 1*time.Second, "Interval between container housekeepings") var cgroupPathRegExp = regexp.MustCompile(`devices[^:]*:(.*?)[,;$]`) type containerInfo struct { info.ContainerReference Subcontainers []info.ContainerReference Spec info.ContainerSpec } type containerData struct { handler container.ContainerHandler info containerInfo memoryCache *memory.InMemoryCache lock sync.Mutex loadReader cpuload.CpuLoadReader summaryReader *summary.StatsSummary loadAvg float64 // smoothed load average seen so far. housekeepingInterval time.Duration maxHousekeepingInterval time.Duration allowDynamicHousekeeping bool lastUpdatedTime time.Time lastErrorTime time.Time // Decay value used for load average smoothing. Interval length of 10 seconds is used. loadDecay float64 // Whether to log the usage of this container when it is updated. logUsage bool // Tells the container to stop. stop chan bool // Runs custom metric collectors. collectorManager collector.CollectorManager } // jitter returns a time.Duration between duration and duration + maxFactor * duration, // to allow clients to avoid converging on periodic behavior. If maxFactor is 0.0, a // suggested default value will be chosen. func jitter(duration time.Duration, maxFactor float64) time.Duration { if maxFactor <= 0.0 { maxFactor = 1.0 } wait := duration + time.Duration(rand.Float64()*maxFactor*float64(duration)) return wait } func (c *containerData) Start() error { go c.housekeeping() return nil } func (c *containerData) Stop() error { err := c.memoryCache.RemoveContainer(c.info.Name) if err != nil { return err } c.stop <- true return nil } func (c *containerData) allowErrorLogging() bool { if time.Since(c.lastErrorTime) > time.Minute { c.lastErrorTime = time.Now() return true } return false } func (c *containerData) GetInfo() (*containerInfo, error) { // Get spec and subcontainers. if time.Since(c.lastUpdatedTime) > 5*time.Second { err := c.updateSpec() if err != nil { return nil, err } err = c.updateSubcontainers() if err != nil { return nil, err } c.lastUpdatedTime = time.Now() } // Make a copy of the info for the user. c.lock.Lock() defer c.lock.Unlock() return &c.info, nil } func (c *containerData) DerivedStats() (v2.DerivedStats, error) { if c.summaryReader == nil { return v2.DerivedStats{}, fmt.Errorf("derived stats not enabled for container %q", c.info.Name) } return c.summaryReader.DerivedStats() } func (c *containerData) getCgroupPath(cgroups string) (string, error) { if cgroups == "-" { return "/", nil } matches := cgroupPathRegExp.FindSubmatch([]byte(cgroups)) if len(matches) != 2 { glog.V(3).Infof("failed to get devices cgroup path from %q", cgroups) // return root in case of failures - devices hierarchy might not be enabled. return "/", nil } return string(matches[1]), nil } // Returns contents of a file inside the container root. // Takes in a path relative to container root. func (c *containerData) ReadFile(filepath string, inHostNamespace bool) ([]byte, error) { pids, err := c.getContainerPids(inHostNamespace) if err != nil { return nil, err } // TODO(rjnagal): Optimize by just reading container's cgroup.proc file when in host namespace. rootfs := "/" if !inHostNamespace { rootfs = "/rootfs" } for _, pid := range pids { filePath := path.Join(rootfs, "/proc", pid, "/root", filepath) glog.V(3).Infof("Trying path %q", filePath) data, err := ioutil.ReadFile(filePath) if err == nil { return data, err } } // No process paths could be found. Declare config non-existent. return nil, fmt.Errorf("file %q does not exist.", filepath) } // Return output for ps command in host /proc with specified format func (c *containerData) getPsOutput(inHostNamespace bool, format string) ([]byte, error) { args := []string{} command := "ps" if !inHostNamespace { command = "/usr/sbin/chroot" args = append(args, "/rootfs", "ps") } args = append(args, "-e", "-o", format) out, err := exec.Command(command, args...).Output() if err != nil { return nil, fmt.Errorf("failed to execute %q command: %v", command, err) } return out, err } // Get pids of processes in this container. // A slightly lighterweight call than GetProcessList if other details are not required. func (c *containerData) getContainerPids(inHostNamespace bool) ([]string, error) { format := "pid,cgroup" out, err := c.getPsOutput(inHostNamespace, format) if err != nil { return nil, err } expectedFields := 2 lines := strings.Split(string(out), "\n") pids := []string{} for _, line := range lines[1:] { if len(line) == 0 { continue } fields := strings.Fields(line) if len(fields) < expectedFields { return nil, fmt.Errorf("expected at least %d fields, found %d: output: %q", expectedFields, len(fields), line) } pid := fields[0] cgroup, err := c.getCgroupPath(fields[1]) if err != nil { return nil, fmt.Errorf("could not parse cgroup path from %q: %v", fields[1], err) } if c.info.Name == cgroup { pids = append(pids, pid) } } return pids, nil } func (c *containerData) GetProcessList(cadvisorContainer string, inHostNamespace bool) ([]v2.ProcessInfo, error) { // report all processes for root. isRoot := c.info.Name == "/" format := "user,pid,ppid,stime,pcpu,pmem,rss,vsz,stat,time,comm,cgroup" out, err := c.getPsOutput(inHostNamespace, format) if err != nil { return nil, err } expectedFields := 12 processes := []v2.ProcessInfo{} lines := strings.Split(string(out), "\n") for _, line := range lines[1:] { if len(line) == 0 { continue } fields := strings.Fields(line) if len(fields) < expectedFields { return nil, fmt.Errorf("expected at least %d fields, found %d: output: %q", expectedFields, len(fields), line) } pid, err := strconv.Atoi(fields[1]) if err != nil { return nil, fmt.Errorf("invalid pid %q: %v", fields[1], err) } ppid, err := strconv.Atoi(fields[2]) if err != nil { return nil, fmt.Errorf("invalid ppid %q: %v", fields[2], err) } percentCpu, err := strconv.ParseFloat(fields[4], 32) if err != nil { return nil, fmt.Errorf("invalid cpu percent %q: %v", fields[4], err) } percentMem, err := strconv.ParseFloat(fields[5], 32) if err != nil { return nil, fmt.Errorf("invalid memory percent %q: %v", fields[5], err) } rss, err := strconv.ParseUint(fields[6], 0, 64) if err != nil { return nil, fmt.Errorf("invalid rss %q: %v", fields[6], err) } // convert to bytes rss *= 1024 vs, err := strconv.ParseUint(fields[7], 0, 64) if err != nil { return nil, fmt.Errorf("invalid virtual size %q: %v", fields[7], err) } // convert to bytes vs *= 1024 cgroup, err := c.getCgroupPath(fields[11]) if err != nil { return nil, fmt.Errorf("could not parse cgroup path from %q: %v", fields[11], err) } // Remove the ps command we just ran from cadvisor container. // Not necessary, but makes the cadvisor page look cleaner. if !inHostNamespace && cadvisorContainer == cgroup && fields[10] == "ps" { continue } var cgroupPath string if isRoot { cgroupPath = cgroup } if isRoot || c.info.Name == cgroup { processes = append(processes, v2.ProcessInfo{ User: fields[0], Pid: pid, Ppid: ppid, StartTime: fields[3], PercentCpu: float32(percentCpu), PercentMemory: float32(percentMem), RSS: rss, VirtualSize: vs, Status: fields[8], RunningTime: fields[9], Cmd: fields[10], CgroupPath: cgroupPath, }) } } return processes, nil } func newContainerData(containerName string, memoryCache *memory.InMemoryCache, handler container.ContainerHandler, logUsage bool, collectorManager collector.CollectorManager, maxHousekeepingInterval time.Duration, allowDynamicHousekeeping bool) (*containerData, error) { if memoryCache == nil { return nil, fmt.Errorf("nil memory storage") } if handler == nil { return nil, fmt.Errorf("nil container handler") } ref, err := handler.ContainerReference() if err != nil { return nil, err } cont := &containerData{ handler: handler, memoryCache: memoryCache, housekeepingInterval: *HousekeepingInterval, maxHousekeepingInterval: maxHousekeepingInterval, allowDynamicHousekeeping: allowDynamicHousekeeping, logUsage: logUsage, loadAvg: -1.0, // negative value indicates uninitialized. stop: make(chan bool, 1), collectorManager: collectorManager, } cont.info.ContainerReference = ref cont.loadDecay = math.Exp(float64(-cont.housekeepingInterval.Seconds() / 10)) if *enableLoadReader { // Create cpu load reader. loadReader, err := cpuload.New() if err != nil { // TODO(rjnagal): Promote to warning once we support cpu load inside namespaces. glog.Infof("Could not initialize cpu load reader for %q: %s", ref.Name, err) } else { cont.loadReader = loadReader } } err = cont.updateSpec() if err != nil { return nil, err } cont.summaryReader, err = summary.New(cont.info.Spec) if err != nil { cont.summaryReader = nil glog.Warningf("Failed to create summary reader for %q: %v", ref.Name, err) } return cont, nil } // Determine when the next housekeeping should occur. func (self *containerData) nextHousekeeping(lastHousekeeping time.Time) time.Time { if self.allowDynamicHousekeeping { var empty time.Time stats, err := self.memoryCache.RecentStats(self.info.Name, empty, empty, 2) if err != nil { if self.allowErrorLogging() { glog.Warningf("Failed to get RecentStats(%q) while determining the next housekeeping: %v", self.info.Name, err) } } else if len(stats) == 2 { // TODO(vishnuk): Use no processes as a signal. // Raise the interval if usage hasn't changed in the last housekeeping. if stats[0].StatsEq(stats[1]) && (self.housekeepingInterval < self.maxHousekeepingInterval) { self.housekeepingInterval *= 2 if self.housekeepingInterval > self.maxHousekeepingInterval { self.housekeepingInterval = self.maxHousekeepingInterval } } else if self.housekeepingInterval != *HousekeepingInterval { // Lower interval back to the baseline. self.housekeepingInterval = *HousekeepingInterval } } } return lastHousekeeping.Add(jitter(self.housekeepingInterval, 1.0)) } // TODO(vmarmol): Implement stats collecting as a custom collector. func (c *containerData) housekeeping() { // Start any background goroutines - must be cleaned up in c.handler.Cleanup(). c.handler.Start() defer c.handler.Cleanup() // Initialize cpuload reader - must be cleaned up in c.loadReader.Stop() if c.loadReader != nil { err := c.loadReader.Start() if err != nil { glog.Warningf("Could not start cpu load stat collector for %q: %s", c.info.Name, err) } defer c.loadReader.Stop() } // Long housekeeping is either 100ms or half of the housekeeping interval. longHousekeeping := 100 * time.Millisecond if *HousekeepingInterval/2 < longHousekeeping { longHousekeeping = *HousekeepingInterval / 2 } // Housekeep every second. glog.V(3).Infof("Start housekeeping for container %q\n", c.info.Name) lastHousekeeping := time.Now() for { select { case <-c.stop: // Stop housekeeping when signaled. return default: // Perform housekeeping. start := time.Now() c.housekeepingTick() // Log if housekeeping took too long. duration := time.Since(start) if duration >= longHousekeeping { glog.V(3).Infof("[%s] Housekeeping took %s", c.info.Name, duration) } } // Log usage if asked to do so. if c.logUsage { const numSamples = 60 var empty time.Time stats, err := c.memoryCache.RecentStats(c.info.Name, empty, empty, numSamples) if err != nil { if c.allowErrorLogging() { glog.Infof("[%s] Failed to get recent stats for logging usage: %v", c.info.Name, err) } } else if len(stats) < numSamples { // Ignore, not enough stats yet. } else { usageCpuNs := uint64(0) for i := range stats { if i > 0 { usageCpuNs += (stats[i].Cpu.Usage.Total - stats[i-1].Cpu.Usage.Total) } } usageMemory := stats[numSamples-1].Memory.Usage instantUsageInCores := float64(stats[numSamples-1].Cpu.Usage.Total-stats[numSamples-2].Cpu.Usage.Total) / float64(stats[numSamples-1].Timestamp.Sub(stats[numSamples-2].Timestamp).Nanoseconds()) usageInCores := float64(usageCpuNs) / float64(stats[numSamples-1].Timestamp.Sub(stats[0].Timestamp).Nanoseconds()) usageInHuman := units.HumanSize(float64(usageMemory)) glog.Infof("[%s] %.3f cores (average: %.3f cores), %s of memory", c.info.Name, instantUsageInCores, usageInCores, usageInHuman) } } next := c.nextHousekeeping(lastHousekeeping) // Schedule the next housekeeping. Sleep until that time. if time.Now().Before(next) { time.Sleep(next.Sub(time.Now())) } else { next = time.Now() } lastHousekeeping = next } } func (c *containerData) housekeepingTick() { err := c.updateStats() if err != nil { if c.allowErrorLogging() { glog.Infof("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 { // Ignore errors if the container is dead. if !c.handler.Exists() { return nil } return err } customMetrics, err := c.collectorManager.GetSpec() if err != nil { return err } if len(customMetrics) > 0 { spec.HasCustomMetrics = true spec.CustomMetrics = customMetrics } c.lock.Lock() defer c.lock.Unlock() c.info.Spec = spec return nil } // Calculate new smoothed load average using the new sample of runnable threads. // The decay used ensures that the load will stabilize on a new constant value within // 10 seconds. func (c *containerData) updateLoad(newLoad uint64) { if c.loadAvg < 0 { c.loadAvg = float64(newLoad) // initialize to the first seen sample for faster stabilization. } else { c.loadAvg = c.loadAvg*c.loadDecay + float64(newLoad)*(1.0-c.loadDecay) } } func (c *containerData) updateStats() error { stats, statsErr := c.handler.GetStats() if statsErr != nil { // Ignore errors if the container is dead. if !c.handler.Exists() { return nil } // Stats may be partially populated, push those before we return an error. statsErr = fmt.Errorf("%v, continuing to push stats", statsErr) } if stats == nil { return statsErr } if c.loadReader != nil { // TODO(vmarmol): Cache this path. path, err := c.handler.GetCgroupPath("cpu") if err == nil { loadStats, err := c.loadReader.GetCpuLoad(c.info.Name, path) if err != nil { return fmt.Errorf("failed to get load stat for %q - path %q, error %s", c.info.Name, path, err) } stats.TaskStats = loadStats c.updateLoad(loadStats.NrRunning) // convert to 'milliLoad' to avoid floats and preserve precision. stats.Cpu.LoadAverage = int32(c.loadAvg * 1000) } } if c.summaryReader != nil { err := c.summaryReader.AddSample(*stats) if err != nil { // Ignore summary errors for now. glog.V(2).Infof("Failed to add summary stats for %q: %v", c.info.Name, err) } } var customStatsErr error cm := c.collectorManager.(*collector.GenericCollectorManager) if len(cm.Collectors) > 0 { if cm.NextCollectionTime.Before(time.Now()) { customStats, err := c.updateCustomStats() if customStats != nil { stats.CustomMetrics = customStats } if err != nil { customStatsErr = err } } } ref, err := c.handler.ContainerReference() if err != nil { // Ignore errors if the container is dead. if !c.handler.Exists() { return nil } return err } err = c.memoryCache.AddStats(ref, stats) if err != nil { return err } if statsErr != nil { return statsErr } return customStatsErr } func (c *containerData) updateCustomStats() (map[string][]info.MetricVal, error) { _, customStats, customStatsErr := c.collectorManager.Collect() if customStatsErr != nil { if !c.handler.Exists() { return customStats, nil } customStatsErr = fmt.Errorf("%v, continuing to push custom stats", customStatsErr) } return customStats, customStatsErr } func (c *containerData) updateSubcontainers() error { var subcontainers info.ContainerReferenceSlice subcontainers, err := c.handler.ListContainers(container.ListSelf) if err != nil { // Ignore errors if the container is dead. if !c.handler.Exists() { return nil } return err } sort.Sort(subcontainers) c.lock.Lock() defer c.lock.Unlock() c.info.Subcontainers = subcontainers return nil } cadvisor-0.25.0/manager/container_test.go000066400000000000000000000127751306035727200204130ustar00rootroot00000000000000// 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" "reflect" "testing" "time" "github.com/google/cadvisor/cache/memory" "github.com/google/cadvisor/collector" "github.com/google/cadvisor/container" containertest "github.com/google/cadvisor/container/testing" info "github.com/google/cadvisor/info/v1" itest "github.com/google/cadvisor/info/v1/test" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) const containerName = "/container" // Create a containerData instance for a test. func setupContainerData(t *testing.T, spec info.ContainerSpec) (*containerData, *containertest.MockContainerHandler, *memory.InMemoryCache) { mockHandler := containertest.NewMockContainerHandler(containerName) mockHandler.On("GetSpec").Return( spec, nil, ) memoryCache := memory.New(60, nil) ret, err := newContainerData(containerName, memoryCache, mockHandler, false, &collector.GenericCollectorManager{}, 60*time.Second, true) if err != nil { t.Fatal(err) } return ret, mockHandler, memoryCache } // Create a containerData instance for a test and add a default GetSpec mock. func newTestContainerData(t *testing.T) (*containerData, *containertest.MockContainerHandler, *memory.InMemoryCache) { spec := itest.GenerateRandomContainerSpec(4) ret, mockHandler, memoryCache := setupContainerData(t, spec) return ret, mockHandler, memoryCache } func TestUpdateSubcontainers(t *testing.T) { subcontainers := []info.ContainerReference{ {Name: "/container/ee0103"}, {Name: "/container/abcd"}, {Name: "/container/something"}, } cd, mockHandler, _ := newTestContainerData(t) mockHandler.On("ListContainers", container.ListSelf).Return( subcontainers, nil, ) err := cd.updateSubcontainers() if err != nil { t.Fatal(err) } if len(cd.info.Subcontainers) != len(subcontainers) { t.Errorf("Received %v subcontainers, should be %v", len(cd.info.Subcontainers), len(subcontainers)) } for _, sub := range cd.info.Subcontainers { found := false for _, sub2 := range subcontainers { if sub.Name == sub2.Name { found = true } } if !found { t.Errorf("Received unknown sub container %v", sub) } } mockHandler.AssertExpectations(t) } func TestUpdateSubcontainersWithError(t *testing.T) { cd, mockHandler, _ := newTestContainerData(t) mockHandler.On("ListContainers", container.ListSelf).Return( []info.ContainerReference{}, fmt.Errorf("some error"), ) mockHandler.On("Exists").Return(true) assert.NotNil(t, cd.updateSubcontainers()) assert.Empty(t, cd.info.Subcontainers, "subcontainers should not be populated on failure") mockHandler.AssertExpectations(t) } func TestUpdateSubcontainersWithErrorOnDeadContainer(t *testing.T) { cd, mockHandler, _ := newTestContainerData(t) mockHandler.On("ListContainers", container.ListSelf).Return( []info.ContainerReference{}, fmt.Errorf("some error"), ) mockHandler.On("Exists").Return(false) assert.Nil(t, cd.updateSubcontainers()) mockHandler.AssertExpectations(t) } func checkNumStats(t *testing.T, memoryCache *memory.InMemoryCache, numStats int) { var empty time.Time stats, err := memoryCache.RecentStats(containerName, empty, empty, -1) require.Nil(t, err) assert.Len(t, stats, numStats) } func TestUpdateStats(t *testing.T) { statsList := itest.GenerateRandomStats(1, 4, 1*time.Second) stats := statsList[0] cd, mockHandler, memoryCache := newTestContainerData(t) mockHandler.On("GetStats").Return( stats, nil, ) err := cd.updateStats() if err != nil { t.Fatal(err) } checkNumStats(t, memoryCache, 1) mockHandler.AssertExpectations(t) } func TestUpdateSpec(t *testing.T) { spec := itest.GenerateRandomContainerSpec(4) cd, mockHandler, _ := newTestContainerData(t) mockHandler.On("GetSpec").Return( spec, nil, ) err := cd.updateSpec() if err != nil { t.Fatal(err) } mockHandler.AssertExpectations(t) } func TestGetInfo(t *testing.T) { spec := itest.GenerateRandomContainerSpec(4) subcontainers := []info.ContainerReference{ {Name: "/container/ee0103"}, {Name: "/container/abcd"}, {Name: "/container/something"}, } cd, mockHandler, _ := setupContainerData(t, spec) mockHandler.On("ListContainers", container.ListSelf).Return( subcontainers, nil, ) mockHandler.Aliases = []string{"a1", "a2"} info, err := cd.GetInfo() if err != nil { t.Fatal(err) } mockHandler.AssertExpectations(t) if len(info.Subcontainers) != len(subcontainers) { t.Errorf("Received %v subcontainers, should be %v", len(info.Subcontainers), len(subcontainers)) } for _, sub := range info.Subcontainers { found := false for _, sub2 := range subcontainers { if sub.Name == sub2.Name { found = true } } if !found { t.Errorf("Received unknown sub container %v", sub) } } if !reflect.DeepEqual(spec, info.Spec) { t.Errorf("received wrong container spec") } if info.Name != mockHandler.Name { t.Errorf("received wrong container name: received %v; should be %v", info.Name, mockHandler.Name) } } cadvisor-0.25.0/manager/manager.go000066400000000000000000001154661306035727200170050ustar00rootroot00000000000000// 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. // Manager of cAdvisor-monitored containers. package manager import ( "flag" "fmt" "os" "path" "strconv" "strings" "sync" "time" "github.com/google/cadvisor/cache/memory" "github.com/google/cadvisor/collector" "github.com/google/cadvisor/container" "github.com/google/cadvisor/container/docker" "github.com/google/cadvisor/container/raw" "github.com/google/cadvisor/container/rkt" "github.com/google/cadvisor/container/systemd" "github.com/google/cadvisor/events" "github.com/google/cadvisor/fs" info "github.com/google/cadvisor/info/v1" "github.com/google/cadvisor/info/v2" "github.com/google/cadvisor/machine" "github.com/google/cadvisor/manager/watcher" rawwatcher "github.com/google/cadvisor/manager/watcher/raw" rktwatcher "github.com/google/cadvisor/manager/watcher/rkt" "github.com/google/cadvisor/utils/oomparser" "github.com/google/cadvisor/utils/sysfs" "github.com/google/cadvisor/version" "net/http" "github.com/golang/glog" "github.com/opencontainers/runc/libcontainer/cgroups" ) var globalHousekeepingInterval = flag.Duration("global_housekeeping_interval", 1*time.Minute, "Interval between global housekeepings") var logCadvisorUsage = flag.Bool("log_cadvisor_usage", false, "Whether to log the usage of the cAdvisor container") var eventStorageAgeLimit = flag.String("event_storage_age_limit", "default=24h", "Max length of time for which to store events (per type). Value is a comma separated list of key values, where the keys are event types (e.g.: creation, oom) or \"default\" and the value is a duration. Default is applied to all non-specified event types") var eventStorageEventLimit = flag.String("event_storage_event_limit", "default=100000", "Max number of events to store (per type). Value is a comma separated list of key values, where the keys are event types (e.g.: creation, oom) or \"default\" and the value is an integer. Default is applied to all non-specified event types") var applicationMetricsCountLimit = flag.Int("application_metrics_count_limit", 100, "Max number of application metrics to store (per container)") // The Manager interface defines operations for starting a manager and getting // container and machine information. type Manager interface { // Start the manager. Calling other manager methods before this returns // may produce undefined behavior. Start() error // Stops the manager. Stop() error // information about a container. GetContainerInfo(containerName string, query *info.ContainerInfoRequest) (*info.ContainerInfo, error) // Get V2 information about a container. // Recursive (subcontainer) requests are best-effort, and may return a partial result alongside an // error in the partial failure case. GetContainerInfoV2(containerName string, options v2.RequestOptions) (map[string]v2.ContainerInfo, error) // Get information about all subcontainers of the specified container (includes self). SubcontainersInfo(containerName string, query *info.ContainerInfoRequest) ([]*info.ContainerInfo, error) // Gets all the Docker containers. Return is a map from full container name to ContainerInfo. AllDockerContainers(query *info.ContainerInfoRequest) (map[string]info.ContainerInfo, error) // Gets information about a specific Docker container. The specified name is within the Docker namespace. DockerContainer(dockerName string, query *info.ContainerInfoRequest) (info.ContainerInfo, error) // Gets spec for all containers based on request options. GetContainerSpec(containerName string, options v2.RequestOptions) (map[string]v2.ContainerSpec, error) // Gets summary stats for all containers based on request options. GetDerivedStats(containerName string, options v2.RequestOptions) (map[string]v2.DerivedStats, error) // Get info for all requested containers based on the request options. GetRequestedContainersInfo(containerName string, options v2.RequestOptions) (map[string]*info.ContainerInfo, error) // Returns true if the named container exists. Exists(containerName string) bool // Get information about the machine. GetMachineInfo() (*info.MachineInfo, error) // Get version information about different components we depend on. GetVersionInfo() (*info.VersionInfo, error) // Get filesystem information for the filesystem that contains the given directory GetDirFsInfo(dir string) (v2.FsInfo, error) // Get filesystem information for a given label. // Returns information for all global filesystems if label is empty. GetFsInfo(label string) ([]v2.FsInfo, error) // Get ps output for a container. GetProcessList(containerName string, options v2.RequestOptions) ([]v2.ProcessInfo, error) // Get events streamed through passedChannel that fit the request. WatchForEvents(request *events.Request) (*events.EventChannel, error) // Get past events that have been detected and that fit the request. GetPastEvents(request *events.Request) ([]*info.Event, error) CloseEventChannel(watch_id int) // Get status information about docker. DockerInfo() (info.DockerStatus, error) // Get details about interesting docker images. DockerImages() ([]info.DockerImage, error) // Returns debugging information. Map of lines per category. DebugInfo() map[string][]string } // New takes a memory storage and returns a new manager. func New(memoryCache *memory.InMemoryCache, sysfs sysfs.SysFs, maxHousekeepingInterval time.Duration, allowDynamicHousekeeping bool, ignoreMetricsSet container.MetricSet, collectorHttpClient *http.Client) (Manager, error) { if memoryCache == nil { return nil, fmt.Errorf("manager requires memory storage") } // Detect the container we are running on. selfContainer, err := cgroups.GetThisCgroupDir("cpu") if err != nil { return nil, err } glog.Infof("cAdvisor running in container: %q", selfContainer) dockerStatus, err := docker.Status() if err != nil { glog.Warningf("Unable to connect to Docker: %v", err) } rktPath, err := rkt.RktPath() if err != nil { glog.Warningf("unable to connect to Rkt api service: %v", err) } context := fs.Context{ Docker: fs.DockerContext{ Root: docker.RootDir(), Driver: dockerStatus.Driver, DriverStatus: dockerStatus.DriverStatus, }, RktPath: rktPath, } fsInfo, err := fs.NewFsInfo(context) if err != nil { return nil, err } // If cAdvisor was started with host's rootfs mounted, assume that its running // in its own namespaces. inHostNamespace := false if _, err := os.Stat("/rootfs/proc"); os.IsNotExist(err) { inHostNamespace = true } // Register for new subcontainers. eventsChannel := make(chan watcher.ContainerEvent, 16) newManager := &manager{ containers: make(map[namespacedContainerName]*containerData), quitChannels: make([]chan error, 0, 2), memoryCache: memoryCache, fsInfo: fsInfo, cadvisorContainer: selfContainer, inHostNamespace: inHostNamespace, startupTime: time.Now(), maxHousekeepingInterval: maxHousekeepingInterval, allowDynamicHousekeeping: allowDynamicHousekeeping, ignoreMetrics: ignoreMetricsSet, containerWatchers: []watcher.ContainerWatcher{}, eventsChannel: eventsChannel, collectorHttpClient: collectorHttpClient, } machineInfo, err := machine.Info(sysfs, fsInfo, inHostNamespace) if err != nil { return nil, err } newManager.machineInfo = *machineInfo glog.Infof("Machine: %+v", newManager.machineInfo) versionInfo, err := getVersionInfo() if err != nil { return nil, err } glog.Infof("Version: %+v", *versionInfo) newManager.eventHandler = events.NewEventManager(parseEventsStoragePolicy()) return newManager, nil } // A namespaced container name. type namespacedContainerName struct { // The namespace of the container. Can be empty for the root namespace. Namespace string // The name of the container in this namespace. Name string } type manager struct { containers map[namespacedContainerName]*containerData containersLock sync.RWMutex memoryCache *memory.InMemoryCache fsInfo fs.FsInfo machineInfo info.MachineInfo quitChannels []chan error cadvisorContainer string inHostNamespace bool eventHandler events.EventManager startupTime time.Time maxHousekeepingInterval time.Duration allowDynamicHousekeeping bool ignoreMetrics container.MetricSet containerWatchers []watcher.ContainerWatcher eventsChannel chan watcher.ContainerEvent collectorHttpClient *http.Client } // Start the container manager. func (self *manager) Start() error { err := docker.Register(self, self.fsInfo, self.ignoreMetrics) if err != nil { glog.Warningf("Docker container factory registration failed: %v.", err) } err = rkt.Register(self, self.fsInfo, self.ignoreMetrics) if err != nil { glog.Warningf("Registration of the rkt container factory failed: %v", err) } else { watcher, err := rktwatcher.NewRktContainerWatcher() if err != nil { return err } self.containerWatchers = append(self.containerWatchers, watcher) } err = systemd.Register(self, self.fsInfo, self.ignoreMetrics) if err != nil { glog.Warningf("Registration of the systemd container factory failed: %v", err) } err = raw.Register(self, self.fsInfo, self.ignoreMetrics) if err != nil { glog.Errorf("Registration of the raw container factory failed: %v", err) } rawWatcher, err := rawwatcher.NewRawContainerWatcher() if err != nil { return err } self.containerWatchers = append(self.containerWatchers, rawWatcher) // Watch for OOMs. err = self.watchForNewOoms() if err != nil { glog.Warningf("Could not configure a source for OOM detection, disabling OOM events: %v", err) } // If there are no factories, don't start any housekeeping and serve the information we do have. if !container.HasFactories() { return nil } // Create root and then recover all containers. err = self.createContainer("/", watcher.Raw) if err != nil { return err } glog.Infof("Starting recovery of all containers") err = self.detectSubcontainers("/") if err != nil { return err } glog.Infof("Recovery completed") // Watch for new container. quitWatcher := make(chan error) err = self.watchForNewContainers(quitWatcher) if err != nil { return err } self.quitChannels = append(self.quitChannels, quitWatcher) // Look for new containers in the main housekeeping thread. quitGlobalHousekeeping := make(chan error) self.quitChannels = append(self.quitChannels, quitGlobalHousekeeping) go self.globalHousekeeping(quitGlobalHousekeeping) return nil } func (self *manager) Stop() error { // Stop and wait on all quit channels. for i, c := range self.quitChannels { // Send the exit signal and wait on the thread to exit (by closing the channel). c <- nil err := <-c if err != nil { // Remove the channels that quit successfully. self.quitChannels = self.quitChannels[i:] return err } } self.quitChannels = make([]chan error, 0, 2) return nil } func (self *manager) globalHousekeeping(quit chan error) { // Long housekeeping is either 100ms or half of the housekeeping interval. longHousekeeping := 100 * time.Millisecond if *globalHousekeepingInterval/2 < longHousekeeping { longHousekeeping = *globalHousekeepingInterval / 2 } ticker := time.Tick(*globalHousekeepingInterval) for { select { case t := <-ticker: start := time.Now() // Check for new containers. err := self.detectSubcontainers("/") if err != nil { glog.Errorf("Failed to detect containers: %s", err) } // Log if housekeeping took too long. duration := time.Since(start) if duration >= longHousekeeping { glog.V(3).Infof("Global Housekeeping(%d) took %s", t.Unix(), duration) } case <-quit: // Quit if asked to do so. quit <- nil glog.Infof("Exiting global housekeeping thread") return } } } func (self *manager) getContainerData(containerName string) (*containerData, error) { var cont *containerData var ok bool func() { self.containersLock.RLock() defer self.containersLock.RUnlock() // Ensure we have the container. cont, ok = self.containers[namespacedContainerName{ Name: containerName, }] }() if !ok { return nil, fmt.Errorf("unknown container %q", containerName) } return cont, nil } func (self *manager) GetDerivedStats(containerName string, options v2.RequestOptions) (map[string]v2.DerivedStats, error) { conts, err := self.getRequestedContainers(containerName, options) if err != nil { return nil, err } var errs partialFailure stats := make(map[string]v2.DerivedStats) for name, cont := range conts { d, err := cont.DerivedStats() if err != nil { errs.append(name, "DerivedStats", err) } stats[name] = d } return stats, errs.OrNil() } func (self *manager) GetContainerSpec(containerName string, options v2.RequestOptions) (map[string]v2.ContainerSpec, error) { conts, err := self.getRequestedContainers(containerName, options) if err != nil { return nil, err } var errs partialFailure specs := make(map[string]v2.ContainerSpec) for name, cont := range conts { cinfo, err := cont.GetInfo() if err != nil { errs.append(name, "GetInfo", err) } spec := self.getV2Spec(cinfo) specs[name] = spec } return specs, errs.OrNil() } // Get V2 container spec from v1 container info. func (self *manager) getV2Spec(cinfo *containerInfo) v2.ContainerSpec { spec := self.getAdjustedSpec(cinfo) return v2.ContainerSpecFromV1(&spec, cinfo.Aliases, cinfo.Namespace) } func (self *manager) getAdjustedSpec(cinfo *containerInfo) info.ContainerSpec { spec := cinfo.Spec // Set default value to an actual value if spec.HasMemory { // Memory.Limit is 0 means there's no limit if spec.Memory.Limit == 0 { spec.Memory.Limit = uint64(self.machineInfo.MemoryCapacity) } } return spec } func (self *manager) GetContainerInfo(containerName string, query *info.ContainerInfoRequest) (*info.ContainerInfo, error) { cont, err := self.getContainerData(containerName) if err != nil { return nil, err } return self.containerDataToContainerInfo(cont, query) } func (self *manager) GetContainerInfoV2(containerName string, options v2.RequestOptions) (map[string]v2.ContainerInfo, error) { containers, err := self.getRequestedContainers(containerName, options) if err != nil { return nil, err } var errs partialFailure var nilTime time.Time // Ignored. infos := make(map[string]v2.ContainerInfo, len(containers)) for name, container := range containers { result := v2.ContainerInfo{} cinfo, err := container.GetInfo() if err != nil { errs.append(name, "GetInfo", err) infos[name] = result continue } result.Spec = self.getV2Spec(cinfo) stats, err := self.memoryCache.RecentStats(name, nilTime, nilTime, options.Count) if err != nil { errs.append(name, "RecentStats", err) infos[name] = result continue } result.Stats = v2.ContainerStatsFromV1(containerName, &cinfo.Spec, stats) infos[name] = result } return infos, errs.OrNil() } func (self *manager) containerDataToContainerInfo(cont *containerData, query *info.ContainerInfoRequest) (*info.ContainerInfo, error) { // Get the info from the container. cinfo, err := cont.GetInfo() if err != nil { return nil, err } stats, err := self.memoryCache.RecentStats(cinfo.Name, query.Start, query.End, query.NumStats) if err != nil { return nil, err } // Make a copy of the info for the user. ret := &info.ContainerInfo{ ContainerReference: cinfo.ContainerReference, Subcontainers: cinfo.Subcontainers, Spec: self.getAdjustedSpec(cinfo), Stats: stats, } return ret, nil } func (self *manager) getContainer(containerName string) (*containerData, error) { self.containersLock.RLock() defer self.containersLock.RUnlock() cont, ok := self.containers[namespacedContainerName{Name: containerName}] if !ok { return nil, fmt.Errorf("unknown container %q", containerName) } return cont, nil } func (self *manager) getSubcontainers(containerName string) map[string]*containerData { self.containersLock.RLock() defer self.containersLock.RUnlock() containersMap := make(map[string]*containerData, len(self.containers)) // Get all the unique subcontainers of the specified container matchedName := path.Join(containerName, "/") for i := range self.containers { name := self.containers[i].info.Name if name == containerName || strings.HasPrefix(name, matchedName) { containersMap[self.containers[i].info.Name] = self.containers[i] } } return containersMap } func (self *manager) SubcontainersInfo(containerName string, query *info.ContainerInfoRequest) ([]*info.ContainerInfo, error) { containersMap := self.getSubcontainers(containerName) containers := make([]*containerData, 0, len(containersMap)) for _, cont := range containersMap { containers = append(containers, cont) } return self.containerDataSliceToContainerInfoSlice(containers, query) } func (self *manager) getAllDockerContainers() map[string]*containerData { self.containersLock.RLock() defer self.containersLock.RUnlock() containers := make(map[string]*containerData, len(self.containers)) // Get containers in the Docker namespace. for name, cont := range self.containers { if name.Namespace == docker.DockerNamespace { containers[cont.info.Name] = cont } } return containers } func (self *manager) AllDockerContainers(query *info.ContainerInfoRequest) (map[string]info.ContainerInfo, error) { containers := self.getAllDockerContainers() output := make(map[string]info.ContainerInfo, len(containers)) for name, cont := range containers { inf, err := self.containerDataToContainerInfo(cont, query) if err != nil { return nil, err } output[name] = *inf } return output, nil } func (self *manager) getDockerContainer(containerName string) (*containerData, error) { self.containersLock.RLock() defer self.containersLock.RUnlock() // Check for the container in the Docker container namespace. cont, ok := self.containers[namespacedContainerName{ Namespace: docker.DockerNamespace, Name: containerName, }] if !ok { return nil, fmt.Errorf("unable to find Docker container %q", containerName) } return cont, nil } func (self *manager) DockerContainer(containerName string, query *info.ContainerInfoRequest) (info.ContainerInfo, error) { container, err := self.getDockerContainer(containerName) if err != nil { return info.ContainerInfo{}, err } inf, err := self.containerDataToContainerInfo(container, query) if err != nil { return info.ContainerInfo{}, err } return *inf, nil } func (self *manager) containerDataSliceToContainerInfoSlice(containers []*containerData, query *info.ContainerInfoRequest) ([]*info.ContainerInfo, error) { if len(containers) == 0 { return nil, fmt.Errorf("no containers found") } // Get the info for each container. output := make([]*info.ContainerInfo, 0, len(containers)) for i := range containers { cinfo, err := self.containerDataToContainerInfo(containers[i], query) if err != nil { // Skip containers with errors, we try to degrade gracefully. continue } output = append(output, cinfo) } return output, nil } func (self *manager) GetRequestedContainersInfo(containerName string, options v2.RequestOptions) (map[string]*info.ContainerInfo, error) { containers, err := self.getRequestedContainers(containerName, options) if err != nil { return nil, err } var errs partialFailure containersMap := make(map[string]*info.ContainerInfo) query := info.ContainerInfoRequest{ NumStats: options.Count, } for name, data := range containers { info, err := self.containerDataToContainerInfo(data, &query) if err != nil { errs.append(name, "containerDataToContainerInfo", err) } containersMap[name] = info } return containersMap, errs.OrNil() } func (self *manager) getRequestedContainers(containerName string, options v2.RequestOptions) (map[string]*containerData, error) { containersMap := make(map[string]*containerData) switch options.IdType { case v2.TypeName: if options.Recursive == false { cont, err := self.getContainer(containerName) if err != nil { return containersMap, err } containersMap[cont.info.Name] = cont } else { containersMap = self.getSubcontainers(containerName) if len(containersMap) == 0 { return containersMap, fmt.Errorf("unknown container: %q", containerName) } } case v2.TypeDocker: if options.Recursive == false { containerName = strings.TrimPrefix(containerName, "/") cont, err := self.getDockerContainer(containerName) if err != nil { return containersMap, err } containersMap[cont.info.Name] = cont } else { if containerName != "/" { return containersMap, fmt.Errorf("invalid request for docker container %q with subcontainers", containerName) } containersMap = self.getAllDockerContainers() } default: return containersMap, fmt.Errorf("invalid request type %q", options.IdType) } return containersMap, nil } func (self *manager) GetDirFsInfo(dir string) (v2.FsInfo, error) { dirDevice, err := self.fsInfo.GetDirFsDevice(dir) if err != nil { return v2.FsInfo{}, fmt.Errorf("error trying to get filesystem Device for dir %v: err: %v", dir, err) } dirMountpoint, err := self.fsInfo.GetMountpointForDevice(dirDevice.Device) if err != nil { return v2.FsInfo{}, fmt.Errorf("error trying to get MountPoint for Root Device: %v, err: %v", dirDevice, err) } infos, err := self.GetFsInfo("") if err != nil { return v2.FsInfo{}, err } for _, info := range infos { if info.Mountpoint == dirMountpoint { return info, nil } } return v2.FsInfo{}, fmt.Errorf("did not find fs info for dir: %v", dir) } func (self *manager) GetFsInfo(label string) ([]v2.FsInfo, error) { var empty time.Time // Get latest data from filesystems hanging off root container. stats, err := self.memoryCache.RecentStats("/", empty, empty, 1) if err != nil { return nil, err } dev := "" if len(label) != 0 { dev, err = self.fsInfo.GetDeviceForLabel(label) if err != nil { return nil, err } } fsInfo := []v2.FsInfo{} for i := range stats[0].Filesystem { fs := stats[0].Filesystem[i] if len(label) != 0 && fs.Device != dev { continue } mountpoint, err := self.fsInfo.GetMountpointForDevice(fs.Device) if err != nil { return nil, err } labels, err := self.fsInfo.GetLabelsForDevice(fs.Device) if err != nil { return nil, err } fi := v2.FsInfo{ Device: fs.Device, Mountpoint: mountpoint, Capacity: fs.Limit, Usage: fs.Usage, Available: fs.Available, Labels: labels, } if fs.HasInodes { fi.Inodes = &fs.Inodes fi.InodesFree = &fs.InodesFree } fsInfo = append(fsInfo, fi) } return fsInfo, nil } func (m *manager) GetMachineInfo() (*info.MachineInfo, error) { // Copy and return the MachineInfo. return &m.machineInfo, nil } func (m *manager) GetVersionInfo() (*info.VersionInfo, error) { // TODO: Consider caching this and periodically updating. The VersionInfo may change if // the docker daemon is started after the cAdvisor client is created. Caching the value // would be helpful so we would be able to return the last known docker version if // docker was down at the time of a query. return getVersionInfo() } func (m *manager) Exists(containerName string) bool { m.containersLock.Lock() defer m.containersLock.Unlock() namespacedName := namespacedContainerName{ Name: containerName, } _, ok := m.containers[namespacedName] if ok { return true } return false } func (m *manager) GetProcessList(containerName string, options v2.RequestOptions) ([]v2.ProcessInfo, error) { // override recursive. Only support single container listing. options.Recursive = false conts, err := m.getRequestedContainers(containerName, options) if err != nil { return nil, err } if len(conts) != 1 { return nil, fmt.Errorf("Expected the request to match only one container") } // TODO(rjnagal): handle count? Only if we can do count by type (eg. top 5 cpu users) ps := []v2.ProcessInfo{} for _, cont := range conts { ps, err = cont.GetProcessList(m.cadvisorContainer, m.inHostNamespace) if err != nil { return nil, err } } return ps, nil } func (m *manager) registerCollectors(collectorConfigs map[string]string, cont *containerData) error { for k, v := range collectorConfigs { configFile, err := cont.ReadFile(v, m.inHostNamespace) if err != nil { return fmt.Errorf("failed to read config file %q for config %q, container %q: %v", k, v, cont.info.Name, err) } glog.V(3).Infof("Got config from %q: %q", v, configFile) if strings.HasPrefix(k, "prometheus") || strings.HasPrefix(k, "Prometheus") { newCollector, err := collector.NewPrometheusCollector(k, configFile, *applicationMetricsCountLimit, cont.handler, m.collectorHttpClient) if err != nil { glog.Infof("failed to create collector for container %q, config %q: %v", cont.info.Name, k, err) return err } err = cont.collectorManager.RegisterCollector(newCollector) if err != nil { glog.Infof("failed to register collector for container %q, config %q: %v", cont.info.Name, k, err) return err } } else { newCollector, err := collector.NewCollector(k, configFile, *applicationMetricsCountLimit, cont.handler, m.collectorHttpClient) if err != nil { glog.Infof("failed to create collector for container %q, config %q: %v", cont.info.Name, k, err) return err } err = cont.collectorManager.RegisterCollector(newCollector) if err != nil { glog.Infof("failed to register collector for container %q, config %q: %v", cont.info.Name, k, err) return err } } } return nil } // Enables overwriting an existing containerData/Handler object for a given containerName. // Can't use createContainer as it just returns if a given containerName has a handler already. // Ex: rkt handler will want to take priority over the raw handler, but the raw handler might be created first. // Only allow raw handler to be overridden func (m *manager) overrideContainer(containerName string, watchSource watcher.ContainerWatchSource) error { m.containersLock.Lock() defer m.containersLock.Unlock() namespacedName := namespacedContainerName{ Name: containerName, } if _, ok := m.containers[namespacedName]; ok { containerData := m.containers[namespacedName] if containerData.handler.Type() != container.ContainerTypeRaw { return nil } err := m.destroyContainerLocked(containerName) if err != nil { return fmt.Errorf("overrideContainer: failed to destroy containerData/handler for %v: %v", containerName, err) } } return m.createContainerLocked(containerName, watchSource) } // Create a container. func (m *manager) createContainer(containerName string, watchSource watcher.ContainerWatchSource) error { m.containersLock.Lock() defer m.containersLock.Unlock() return m.createContainerLocked(containerName, watchSource) } func (m *manager) createContainerLocked(containerName string, watchSource watcher.ContainerWatchSource) error { namespacedName := namespacedContainerName{ Name: containerName, } // Check that the container didn't already exist. if _, ok := m.containers[namespacedName]; ok { return nil } handler, accept, err := container.NewContainerHandler(containerName, watchSource, m.inHostNamespace) if err != nil { return err } if !accept { // ignoring this container. glog.V(4).Infof("ignoring container %q", containerName) return nil } collectorManager, err := collector.NewCollectorManager() if err != nil { return err } logUsage := *logCadvisorUsage && containerName == m.cadvisorContainer cont, err := newContainerData(containerName, m.memoryCache, handler, logUsage, collectorManager, m.maxHousekeepingInterval, m.allowDynamicHousekeeping) if err != nil { return err } // Add collectors labels := handler.GetContainerLabels() collectorConfigs := collector.GetCollectorConfigs(labels) err = m.registerCollectors(collectorConfigs, cont) if err != nil { glog.Infof("failed to register collectors for %q: %v", containerName, err) } // Add the container name and all its aliases. The aliases must be within the namespace of the factory. m.containers[namespacedName] = cont for _, alias := range cont.info.Aliases { m.containers[namespacedContainerName{ Namespace: cont.info.Namespace, Name: alias, }] = cont } glog.V(3).Infof("Added container: %q (aliases: %v, namespace: %q)", containerName, cont.info.Aliases, cont.info.Namespace) contSpec, err := cont.handler.GetSpec() if err != nil { return err } contRef, err := cont.handler.ContainerReference() if err != nil { return err } newEvent := &info.Event{ ContainerName: contRef.Name, Timestamp: contSpec.CreationTime, EventType: info.EventContainerCreation, } err = m.eventHandler.AddEvent(newEvent) if err != nil { return err } // Start the container's housekeeping. return cont.Start() } func (m *manager) destroyContainer(containerName string) error { m.containersLock.Lock() defer m.containersLock.Unlock() return m.destroyContainerLocked(containerName) } func (m *manager) destroyContainerLocked(containerName string) error { namespacedName := namespacedContainerName{ Name: containerName, } cont, ok := m.containers[namespacedName] if !ok { // Already destroyed, done. return nil } // 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, namespacedName) for _, alias := range cont.info.Aliases { delete(m.containers, namespacedContainerName{ Namespace: cont.info.Namespace, Name: alias, }) } glog.V(3).Infof("Destroyed container: %q (aliases: %v, namespace: %q)", containerName, cont.info.Aliases, cont.info.Namespace) contRef, err := cont.handler.ContainerReference() if err != nil { return err } newEvent := &info.Event{ ContainerName: contRef.Name, Timestamp: time.Now(), EventType: info.EventContainerDeletion, } err = m.eventHandler.AddEvent(newEvent) if err != nil { return err } return nil } // Detect all containers that have been added or deleted from the specified container. func (m *manager) getContainersDiff(containerName string) (added []info.ContainerReference, removed []info.ContainerReference, err error) { m.containersLock.RLock() defer m.containersLock.RUnlock() // Get all subcontainers recursively. cont, ok := m.containers[namespacedContainerName{ Name: containerName, }] if !ok { return nil, nil, fmt.Errorf("failed to find container %q while checking for new containers", containerName) } allContainers, err := cont.handler.ListContainers(container.ListRecursive) if err != nil { return nil, nil, err } allContainers = append(allContainers, info.ContainerReference{Name: containerName}) // 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.Name { allContainersSet[name.Name] = d } } // Added containers for _, c := range allContainers { delete(allContainersSet, c.Name) _, ok := m.containers[namespacedContainerName{ Name: 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 subcontainers and reflect the setup here. func (m *manager) detectSubcontainers(containerName string) error { added, removed, err := m.getContainersDiff(containerName) if err != nil { return err } // Add the new containers. for _, cont := range added { err = m.createContainer(cont.Name, watcher.Raw) if err != nil { glog.Errorf("Failed to create existing container: %s: %s", cont.Name, err) } } // Remove the old containers. for _, cont := range removed { err = m.destroyContainer(cont.Name) if err != nil { glog.Errorf("Failed to destroy existing container: %s: %s", cont.Name, err) } } return nil } // Watches for new containers started in the system. Runs forever unless there is a setup error. func (self *manager) watchForNewContainers(quit chan error) error { for _, watcher := range self.containerWatchers { err := watcher.Start(self.eventsChannel) if err != nil { return err } } // There is a race between starting the watch and new container creation so we do a detection before we read new containers. err := self.detectSubcontainers("/") if err != nil { return err } // Listen to events from the container handler. go func() { for { select { case event := <-self.eventsChannel: switch { case event.EventType == watcher.ContainerAdd: switch event.WatchSource { // the Rkt and Raw watchers can race, and if Raw wins, we want Rkt to override and create a new handler for Rkt containers case watcher.Rkt: err = self.overrideContainer(event.Name, event.WatchSource) default: err = self.createContainer(event.Name, event.WatchSource) } case event.EventType == watcher.ContainerDelete: err = self.destroyContainer(event.Name) } if err != nil { glog.Warningf("Failed to process watch event %+v: %v", event, err) } case <-quit: var errs partialFailure // Stop processing events if asked to quit. for i, watcher := range self.containerWatchers { err := watcher.Stop() if err != nil { errs.append(fmt.Sprintf("watcher %d", i), "Stop", err) } } if len(errs) > 0 { quit <- errs } else { quit <- nil glog.Infof("Exiting thread watching subcontainers") return } } } }() return nil } func (self *manager) watchForNewOoms() error { glog.Infof("Started watching for new ooms in manager") outStream := make(chan *oomparser.OomInstance, 10) oomLog, err := oomparser.New() if err != nil { return err } go oomLog.StreamOoms(outStream) go func() { for oomInstance := range outStream { // Surface OOM and OOM kill events. newEvent := &info.Event{ ContainerName: oomInstance.ContainerName, Timestamp: oomInstance.TimeOfDeath, EventType: info.EventOom, } err := self.eventHandler.AddEvent(newEvent) if err != nil { glog.Errorf("failed to add OOM event for %q: %v", oomInstance.ContainerName, err) } glog.V(3).Infof("Created an OOM event in container %q at %v", oomInstance.ContainerName, oomInstance.TimeOfDeath) newEvent = &info.Event{ ContainerName: oomInstance.VictimContainerName, Timestamp: oomInstance.TimeOfDeath, EventType: info.EventOomKill, EventData: info.EventData{ OomKill: &info.OomKillEventData{ Pid: oomInstance.Pid, ProcessName: oomInstance.ProcessName, }, }, } err = self.eventHandler.AddEvent(newEvent) if err != nil { glog.Errorf("failed to add OOM kill event for %q: %v", oomInstance.ContainerName, err) } } }() return nil } // can be called by the api which will take events returned on the channel func (self *manager) WatchForEvents(request *events.Request) (*events.EventChannel, error) { return self.eventHandler.WatchEvents(request) } // can be called by the api which will return all events satisfying the request func (self *manager) GetPastEvents(request *events.Request) ([]*info.Event, error) { return self.eventHandler.GetEvents(request) } // called by the api when a client is no longer listening to the channel func (self *manager) CloseEventChannel(watch_id int) { self.eventHandler.StopWatch(watch_id) } // Parses the events StoragePolicy from the flags. func parseEventsStoragePolicy() events.StoragePolicy { policy := events.DefaultStoragePolicy() // Parse max age. parts := strings.Split(*eventStorageAgeLimit, ",") for _, part := range parts { items := strings.Split(part, "=") if len(items) != 2 { glog.Warningf("Unknown event storage policy %q when parsing max age", part) continue } dur, err := time.ParseDuration(items[1]) if err != nil { glog.Warningf("Unable to parse event max age duration %q: %v", items[1], err) continue } if items[0] == "default" { policy.DefaultMaxAge = dur continue } policy.PerTypeMaxAge[info.EventType(items[0])] = dur } // Parse max number. parts = strings.Split(*eventStorageEventLimit, ",") for _, part := range parts { items := strings.Split(part, "=") if len(items) != 2 { glog.Warningf("Unknown event storage policy %q when parsing max event limit", part) continue } val, err := strconv.Atoi(items[1]) if err != nil { glog.Warningf("Unable to parse integer from %q: %v", items[1], err) continue } if items[0] == "default" { policy.DefaultMaxNumEvents = val continue } policy.PerTypeMaxNumEvents[info.EventType(items[0])] = val } return policy } func (m *manager) DockerImages() ([]info.DockerImage, error) { return docker.Images() } func (m *manager) DockerInfo() (info.DockerStatus, error) { return docker.Status() } func (m *manager) DebugInfo() map[string][]string { debugInfo := container.DebugInfo() // Get unique containers. var conts map[*containerData]struct{} func() { m.containersLock.RLock() defer m.containersLock.RUnlock() conts = make(map[*containerData]struct{}, len(m.containers)) for _, c := range m.containers { conts[c] = struct{}{} } }() // List containers. lines := make([]string, 0, len(conts)) for cont := range conts { lines = append(lines, cont.info.Name) if cont.info.Namespace != "" { lines = append(lines, fmt.Sprintf("\tNamespace: %s", cont.info.Namespace)) } if len(cont.info.Aliases) != 0 { lines = append(lines, "\tAliases:") for _, alias := range cont.info.Aliases { lines = append(lines, fmt.Sprintf("\t\t%s", alias)) } } } debugInfo["Managed containers"] = lines return debugInfo } func getVersionInfo() (*info.VersionInfo, error) { kernel_version := machine.KernelVersion() container_os := machine.ContainerOsVersion() docker_version := docker.VersionString() return &info.VersionInfo{ KernelVersion: kernel_version, ContainerOsVersion: container_os, DockerVersion: docker_version, CadvisorVersion: version.Info["version"], CadvisorRevision: version.Info["revision"], }, nil } // Helper for accumulating partial failures. type partialFailure []string func (f *partialFailure) append(id, operation string, err error) { *f = append(*f, fmt.Sprintf("[%q: %s: %s]", id, operation, err)) } func (f partialFailure) Error() string { return fmt.Sprintf("partial failures: %s", strings.Join(f, ", ")) } func (f partialFailure) OrNil() error { if len(f) == 0 { return nil } return f } cadvisor-0.25.0/manager/manager_test.go000066400000000000000000000207041306035727200200320ustar00rootroot00000000000000// 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" "reflect" "strings" "testing" "time" "net/http" "github.com/google/cadvisor/cache/memory" "github.com/google/cadvisor/collector" "github.com/google/cadvisor/container" "github.com/google/cadvisor/container/docker" containertest "github.com/google/cadvisor/container/testing" info "github.com/google/cadvisor/info/v1" itest "github.com/google/cadvisor/info/v1/test" "github.com/google/cadvisor/info/v2" "github.com/google/cadvisor/utils/sysfs/fakesysfs" "github.com/stretchr/testify/assert" ) // TODO(vmarmol): Refactor these tests. func createManagerAndAddContainers( memoryCache *memory.InMemoryCache, sysfs *fakesysfs.FakeSysFs, containers []string, f func(*containertest.MockContainerHandler), t *testing.T, ) *manager { container.ClearContainerHandlerFactories() mif := &manager{ containers: make(map[namespacedContainerName]*containerData), quitChannels: make([]chan error, 0, 2), memoryCache: memoryCache, } for _, name := range containers { mockHandler := containertest.NewMockContainerHandler(name) spec := itest.GenerateRandomContainerSpec(4) mockHandler.On("GetSpec").Return( spec, nil, ).Once() cont, err := newContainerData(name, memoryCache, mockHandler, false, &collector.GenericCollectorManager{}, 60*time.Second, true) if err != nil { t.Fatal(err) } mif.containers[namespacedContainerName{ Name: name, }] = cont // Add Docker containers under their namespace. if strings.HasPrefix(name, "/docker") { mif.containers[namespacedContainerName{ Namespace: docker.DockerNamespace, Name: strings.TrimPrefix(name, "/docker/"), }] = cont } f(mockHandler) } return mif } // Expect a manager with the specified containers and query. Returns the manager, map of ContainerInfo objects, // and map of MockContainerHandler objects.} func expectManagerWithContainers(containers []string, query *info.ContainerInfoRequest, t *testing.T) (*manager, map[string]*info.ContainerInfo, map[string]*containertest.MockContainerHandler) { infosMap := make(map[string]*info.ContainerInfo, len(containers)) handlerMap := make(map[string]*containertest.MockContainerHandler, len(containers)) for _, container := range containers { infosMap[container] = itest.GenerateRandomContainerInfo(container, 4, query, 1*time.Second) } memoryCache := memory.New(time.Duration(query.NumStats)*time.Second, nil) sysfs := &fakesysfs.FakeSysFs{} m := createManagerAndAddContainers( memoryCache, sysfs, containers, func(h *containertest.MockContainerHandler) { cinfo := infosMap[h.Name] ref, err := h.ContainerReference() if err != nil { t.Error(err) } for _, stat := range cinfo.Stats { err = memoryCache.AddStats(ref, stat) if err != nil { t.Error(err) } } spec := cinfo.Spec h.On("ListContainers", container.ListSelf).Return( []info.ContainerReference(nil), nil, ) h.On("GetSpec").Return( spec, nil, ).Once() handlerMap[h.Name] = h }, t, ) return m, infosMap, handlerMap } func TestGetContainerInfo(t *testing.T) { containers := []string{ "/c1", "/c2", } query := &info.ContainerInfoRequest{ NumStats: 256, } m, infosMap, handlerMap := expectManagerWithContainers(containers, query, t) returnedInfos := make(map[string]*info.ContainerInfo, len(containers)) for _, container := range containers { cinfo, err := m.GetContainerInfo(container, query) if err != nil { t.Fatalf("Unable to get info for container %v: %v", container, err) } returnedInfos[container] = cinfo } for container, handler := range handlerMap { handler.AssertExpectations(t) returned := returnedInfos[container] expected := infosMap[container] if !reflect.DeepEqual(returned, expected) { t.Errorf("returned unexpected info for container %v; returned %+v; expected %+v", container, returned, expected) } } } func TestGetContainerInfoV2(t *testing.T) { containers := []string{ "/", "/c1", "/c2", } options := v2.RequestOptions{ IdType: v2.TypeName, Count: 1, Recursive: true, } query := &info.ContainerInfoRequest{ NumStats: 2, } m, _, handlerMap := expectManagerWithContainers(containers, query, t) infos, err := m.GetContainerInfoV2("/", options) if err != nil { t.Fatalf("GetContainerInfoV2 failed: %v", err) } for container, handler := range handlerMap { handler.AssertExpectations(t) info, ok := infos[container] assert.True(t, ok, "Missing info for container %q", container) assert.NotEqual(t, v2.ContainerSpec{}, info.Spec, "Empty spec for container %q", container) assert.NotEmpty(t, info.Stats, "Missing stats for container %q", container) } } func TestGetContainerInfoV2Failure(t *testing.T) { successful := "/" statless := "/c1" failing := "/c2" containers := []string{ successful, statless, failing, } options := v2.RequestOptions{ IdType: v2.TypeName, Count: 1, Recursive: true, } query := &info.ContainerInfoRequest{ NumStats: 2, } m, _, handlerMap := expectManagerWithContainers(containers, query, t) // Remove /c1 stats err := m.memoryCache.RemoveContainer(statless) if err != nil { t.Fatalf("RemoveContainer failed: %v", err) } // Make GetSpec fail on /c2 mockErr := fmt.Errorf("intentional GetSpec failure") handlerMap[failing].GetSpec() // Use up default GetSpec call, and replace below handlerMap[failing].On("GetSpec").Return(info.ContainerSpec{}, mockErr) handlerMap[failing].On("Exists").Return(true) m.containers[namespacedContainerName{Name: failing}].lastUpdatedTime = time.Time{} // Force GetSpec. infos, err := m.GetContainerInfoV2("/", options) if err == nil { t.Error("Expected error calling GetContainerInfoV2") } // Successful containers still successful. info, ok := infos[successful] assert.True(t, ok, "Missing info for container %q", successful) assert.NotEqual(t, v2.ContainerSpec{}, info.Spec, "Empty spec for container %q", successful) assert.NotEmpty(t, info.Stats, "Missing stats for container %q", successful) // "/c1" present with spec. info, ok = infos[statless] assert.True(t, ok, "Missing info for container %q", statless) assert.NotEqual(t, v2.ContainerSpec{}, info.Spec, "Empty spec for container %q", statless) assert.Empty(t, info.Stats, "Missing stats for container %q", successful) // "/c2" should be present but empty. info, ok = infos[failing] assert.True(t, ok, "Missing info for failed container") assert.Equal(t, v2.ContainerInfo{}, info, "Empty spec for failed container") assert.Empty(t, info.Stats, "Missing stats for failed container") } func TestSubcontainersInfo(t *testing.T) { containers := []string{ "/c1", "/c2", } query := &info.ContainerInfoRequest{ NumStats: 64, } m, _, _ := expectManagerWithContainers(containers, query, t) result, err := m.SubcontainersInfo("/", query) if err != nil { t.Fatalf("expected to succeed: %s", err) } if len(result) != len(containers) { t.Errorf("expected to received containers: %v, but received: %v", containers, result) } for _, res := range result { found := false for _, name := range containers { if res.Name == name { found = true break } } if !found { t.Errorf("unexpected container %q in result, expected one of %v", res.Name, containers) } } } func TestDockerContainersInfo(t *testing.T) { containers := []string{ "/docker/c1", } query := &info.ContainerInfoRequest{ NumStats: 2, } m, _, _ := expectManagerWithContainers(containers, query, t) result, err := m.DockerContainer("c1", query) if err != nil { t.Fatalf("expected to succeed: %s", err) } if result.Name != containers[0] { t.Errorf("Unexpected container %q in result. Expected container %q", result.Name, containers[0]) } } func TestNewNilManager(t *testing.T) { _, err := New(nil, nil, 60*time.Second, true, container.MetricSet{}, http.DefaultClient) if err == nil { t.Fatalf("Expected nil manager to return error") } } cadvisor-0.25.0/manager/watcher/000077500000000000000000000000001306035727200164645ustar00rootroot00000000000000cadvisor-0.25.0/manager/watcher/raw/000077500000000000000000000000001306035727200172555ustar00rootroot00000000000000cadvisor-0.25.0/manager/watcher/raw/raw.go000066400000000000000000000141421306035727200203770ustar00rootroot00000000000000// Copyright 2014 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Package container defines types for sub-container events and also // defines an interface for container operation handlers. package raw import ( "fmt" "io/ioutil" "os" "path" "strings" "github.com/google/cadvisor/container/common" "github.com/google/cadvisor/container/libcontainer" "github.com/google/cadvisor/manager/watcher" "github.com/golang/glog" "golang.org/x/exp/inotify" ) type rawContainerWatcher struct { // Absolute path to the root of the cgroup hierarchies cgroupPaths map[string]string cgroupSubsystems *libcontainer.CgroupSubsystems // Inotify event watcher. watcher *common.InotifyWatcher // Signal for watcher thread to stop. stopWatcher chan error } func NewRawContainerWatcher() (watcher.ContainerWatcher, error) { cgroupSubsystems, err := libcontainer.GetCgroupSubsystems() if err != nil { return nil, fmt.Errorf("failed to get cgroup subsystems: %v", err) } if len(cgroupSubsystems.Mounts) == 0 { return nil, fmt.Errorf("failed to find supported cgroup mounts for the raw factory") } watcher, err := common.NewInotifyWatcher() if err != nil { return nil, err } rawWatcher := &rawContainerWatcher{ cgroupPaths: common.MakeCgroupPaths(cgroupSubsystems.MountPoints, "/"), cgroupSubsystems: &cgroupSubsystems, watcher: watcher, stopWatcher: make(chan error), } return rawWatcher, nil } func (self *rawContainerWatcher) Start(events chan watcher.ContainerEvent) error { // Watch this container (all its cgroups) and all subdirectories. for _, cgroupPath := range self.cgroupPaths { _, err := self.watchDirectory(cgroupPath, "/") if err != nil { return err } } // Process the events received from the kernel. go func() { for { select { case event := <-self.watcher.Event(): err := self.processEvent(event, events) if err != nil { glog.Warningf("Error while processing event (%+v): %v", event, err) } case err := <-self.watcher.Error(): glog.Warningf("Error while watching %q:", "/", err) case <-self.stopWatcher: err := self.watcher.Close() if err == nil { self.stopWatcher <- err return } } } }() return nil } func (self *rawContainerWatcher) Stop() error { // Rendezvous with the watcher thread. self.stopWatcher <- nil return <-self.stopWatcher } // Watches the specified directory and all subdirectories. Returns whether the path was // already being watched and an error (if any). func (self *rawContainerWatcher) watchDirectory(dir string, containerName string) (bool, error) { alreadyWatching, err := self.watcher.AddWatch(containerName, dir) if err != nil { return alreadyWatching, err } // Remove the watch if further operations failed. cleanup := true defer func() { if cleanup { _, err := self.watcher.RemoveWatch(containerName, dir) if err != nil { glog.Warningf("Failed to remove inotify watch for %q: %v", dir, err) } } }() // TODO(vmarmol): We should re-do this once we're done to ensure directories were not added in the meantime. // Watch subdirectories as well. entries, err := ioutil.ReadDir(dir) if err != nil { return alreadyWatching, err } for _, entry := range entries { if entry.IsDir() { entryPath := path.Join(dir, entry.Name()) _, err = self.watchDirectory(entryPath, path.Join(containerName, entry.Name())) if err != nil { glog.Errorf("Failed to watch directory %q: %v", entryPath, err) if os.IsNotExist(err) { // The directory may have been removed before watching. Try to watch the other // subdirectories. (https://github.com/kubernetes/kubernetes/issues/28997) continue } return alreadyWatching, err } } } cleanup = false return alreadyWatching, nil } func (self *rawContainerWatcher) processEvent(event *inotify.Event, events chan watcher.ContainerEvent) error { // Convert the inotify event type to a container create or delete. var eventType watcher.ContainerEventType switch { case (event.Mask & inotify.IN_CREATE) > 0: eventType = watcher.ContainerAdd case (event.Mask & inotify.IN_DELETE) > 0: eventType = watcher.ContainerDelete case (event.Mask & inotify.IN_MOVED_FROM) > 0: eventType = watcher.ContainerDelete case (event.Mask & inotify.IN_MOVED_TO) > 0: eventType = watcher.ContainerAdd default: // Ignore other events. return nil } // Derive the container name from the path name. var containerName string for _, mount := range self.cgroupSubsystems.Mounts { mountLocation := path.Clean(mount.Mountpoint) + "/" if strings.HasPrefix(event.Name, mountLocation) { containerName = event.Name[len(mountLocation)-1:] break } } if containerName == "" { return fmt.Errorf("unable to detect container from watch event on directory %q", event.Name) } // Maintain the watch for the new or deleted container. switch eventType { case watcher.ContainerAdd: // New container was created, watch it. alreadyWatched, err := self.watchDirectory(event.Name, containerName) if err != nil { return err } // Only report container creation once. if alreadyWatched { return nil } case watcher.ContainerDelete: // Container was deleted, stop watching for it. lastWatched, err := self.watcher.RemoveWatch(containerName, event.Name) if err != nil { return err } // Only report container deletion once. if !lastWatched { return nil } default: return fmt.Errorf("unknown event type %v", eventType) } // Deliver the event. events <- watcher.ContainerEvent{ EventType: eventType, Name: containerName, WatchSource: watcher.Raw, } return nil } cadvisor-0.25.0/manager/watcher/rkt/000077500000000000000000000000001306035727200172645ustar00rootroot00000000000000cadvisor-0.25.0/manager/watcher/rkt/rkt.go000066400000000000000000000077301306035727200204220ustar00rootroot00000000000000// Copyright 2016 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Package rkt implements the watcher interface for rkt package rkt import ( "path/filepath" "time" "github.com/google/cadvisor/container/rkt" "github.com/google/cadvisor/manager/watcher" rktapi "github.com/coreos/rkt/api/v1alpha" "github.com/golang/glog" "golang.org/x/net/context" ) type rktContainerWatcher struct { // Signal for watcher thread to stop. stopWatcher chan error } func NewRktContainerWatcher() (watcher.ContainerWatcher, error) { watcher := &rktContainerWatcher{ stopWatcher: make(chan error), } return watcher, nil } func (self *rktContainerWatcher) Start(events chan watcher.ContainerEvent) error { go self.detectRktContainers(events) return nil } func (self *rktContainerWatcher) Stop() error { // Rendezvous with the watcher thread. self.stopWatcher <- nil return nil } func (self *rktContainerWatcher) detectRktContainers(events chan watcher.ContainerEvent) { glog.Infof("starting detectRktContainers thread") ticker := time.Tick(10 * time.Second) curpods := make(map[string]*rktapi.Pod) for { select { case <-ticker: pods, err := listRunningPods() if err != nil { glog.Errorf("detectRktContainers: listRunningPods failed: %v", err) continue } curpods = self.syncRunningPods(pods, events, curpods) case <-self.stopWatcher: glog.Infof("Exiting rktContainer Thread") return } } } func (self *rktContainerWatcher) syncRunningPods(pods []*rktapi.Pod, events chan watcher.ContainerEvent, curpods map[string]*rktapi.Pod) map[string]*rktapi.Pod { newpods := make(map[string]*rktapi.Pod) for _, pod := range pods { newpods[pod.Id] = pod // if pods become mutable, have to handle this better if _, ok := curpods[pod.Id]; !ok { // should create all cgroups not including system.slice // i.e. /system.slice/rkt-test.service and /system.slice/rkt-test.service/system.slice/pause.service for _, cgroup := range podToCgroup(pod) { self.sendUpdateEvent(cgroup, events) } } } for id, pod := range curpods { if _, ok := newpods[id]; !ok { for _, cgroup := range podToCgroup(pod) { glog.Infof("cgroup to delete = %v", cgroup) self.sendDestroyEvent(cgroup, events) } } } return newpods } func (self *rktContainerWatcher) sendUpdateEvent(cgroup string, events chan watcher.ContainerEvent) { events <- watcher.ContainerEvent{ EventType: watcher.ContainerAdd, Name: cgroup, WatchSource: watcher.Rkt, } } func (self *rktContainerWatcher) sendDestroyEvent(cgroup string, events chan watcher.ContainerEvent) { events <- watcher.ContainerEvent{ EventType: watcher.ContainerDelete, Name: cgroup, WatchSource: watcher.Rkt, } } func listRunningPods() ([]*rktapi.Pod, error) { client, err := rkt.Client() if err != nil { return nil, err } resp, err := client.ListPods(context.Background(), &rktapi.ListPodsRequest{ // Specify the request: Fetch and print only running pods and their details. Detail: true, Filters: []*rktapi.PodFilter{ { States: []rktapi.PodState{rktapi.PodState_POD_STATE_RUNNING}, }, }, }) if err != nil { return nil, err } return resp.Pods, nil } func podToCgroup(pod *rktapi.Pod) []string { cgroups := make([]string, 1+len(pod.Apps), 1+len(pod.Apps)) baseCgroup := pod.Cgroup cgroups[0] = baseCgroup for i, app := range pod.Apps { cgroups[i+1] = filepath.Join(baseCgroup, "system.slice", app.Name+".service") } return cgroups } cadvisor-0.25.0/manager/watcher/watcher.go000066400000000000000000000027541306035727200204600ustar00rootroot00000000000000// Copyright 2016 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Package container defines types for sub-container events and also // defines an interface for container operation handlers. package watcher // SubcontainerEventType indicates an addition or deletion event. type ContainerEventType int const ( ContainerAdd ContainerEventType = iota ContainerDelete ) type ContainerWatchSource int const ( Raw ContainerWatchSource = iota Rkt ) // ContainerEvent represents a type ContainerEvent struct { // The type of event that occurred. EventType ContainerEventType // The full container name of the container where the event occurred. Name string // The watcher that detected this change event WatchSource ContainerWatchSource } type ContainerWatcher interface { // Registers a channel to listen for events affecting subcontainers (recursively). Start(events chan ContainerEvent) error // Stops watching for subcontainer changes. Stop() error } cadvisor-0.25.0/metrics/000077500000000000000000000000001306035727200150635ustar00rootroot00000000000000cadvisor-0.25.0/metrics/prometheus.go000066400000000000000000000622541306035727200176160ustar00rootroot00000000000000// 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 metrics import ( "fmt" "regexp" "time" info "github.com/google/cadvisor/info/v1" "github.com/golang/glog" "github.com/prometheus/client_golang/prometheus" ) // infoProvider will usually be manager.Manager, but can be swapped out for testing. type infoProvider interface { // SubcontainersInfo provides information about all subcontainers of the // specified container including itself. SubcontainersInfo(containerName string, query *info.ContainerInfoRequest) ([]*info.ContainerInfo, error) // GetVersionInfo provides information about the version. GetVersionInfo() (*info.VersionInfo, error) // GetMachineInfo provides information about the machine. GetMachineInfo() (*info.MachineInfo, error) } // metricValue describes a single metric value for a given set of label values // within a parent containerMetric. type metricValue struct { value float64 labels []string } type metricValues []metricValue // fsValues is a helper method for assembling per-filesystem stats. func fsValues(fsStats []info.FsStats, valueFn func(*info.FsStats) float64) metricValues { values := make(metricValues, 0, len(fsStats)) for _, stat := range fsStats { values = append(values, metricValue{ value: valueFn(&stat), labels: []string{stat.Device}, }) } return values } // containerMetric describes a multi-dimensional metric used for exposing a // certain type of container statistic. type containerMetric struct { name string help string valueType prometheus.ValueType extraLabels []string condition func(s info.ContainerSpec) bool getValues func(s *info.ContainerStats) metricValues } func (cm *containerMetric) desc(baseLabels []string) *prometheus.Desc { return prometheus.NewDesc(cm.name, cm.help, append(baseLabels, cm.extraLabels...), nil) } // ContainerLabelsFunc defines all base labels and their values attached to // each metric exported by cAdvisor. type ContainerLabelsFunc func(*info.ContainerInfo) map[string]string // PrometheusCollector implements prometheus.Collector. type PrometheusCollector struct { infoProvider infoProvider errors prometheus.Gauge containerMetrics []containerMetric containerLabelsFunc ContainerLabelsFunc } // NewPrometheusCollector returns a new PrometheusCollector. The passed // ContainerLabelsFunc specifies which base labels will be attached to all // exported metrics. If left to nil, the DefaultContainerLabels function // will be used instead. func NewPrometheusCollector(i infoProvider, f ContainerLabelsFunc) *PrometheusCollector { if f == nil { f = DefaultContainerLabels } c := &PrometheusCollector{ infoProvider: i, containerLabelsFunc: f, errors: prometheus.NewGauge(prometheus.GaugeOpts{ Namespace: "container", Name: "scrape_error", Help: "1 if there was an error while getting container metrics, 0 otherwise", }), containerMetrics: []containerMetric{ { name: "container_last_seen", help: "Last time a container was seen by the exporter", valueType: prometheus.GaugeValue, getValues: func(s *info.ContainerStats) metricValues { return metricValues{{value: float64(time.Now().Unix())}} }, }, { name: "container_cpu_user_seconds_total", help: "Cumulative user cpu time consumed in seconds.", valueType: prometheus.CounterValue, getValues: func(s *info.ContainerStats) metricValues { return metricValues{{value: float64(s.Cpu.Usage.User) / float64(time.Second)}} }, }, { name: "container_cpu_system_seconds_total", help: "Cumulative system cpu time consumed in seconds.", valueType: prometheus.CounterValue, getValues: func(s *info.ContainerStats) metricValues { return metricValues{{value: float64(s.Cpu.Usage.System) / float64(time.Second)}} }, }, { name: "container_cpu_usage_seconds_total", help: "Cumulative cpu time consumed per cpu in seconds.", valueType: prometheus.CounterValue, extraLabels: []string{"cpu"}, getValues: func(s *info.ContainerStats) metricValues { values := make(metricValues, 0, len(s.Cpu.Usage.PerCpu)) for i, value := range s.Cpu.Usage.PerCpu { values = append(values, metricValue{ value: float64(value) / float64(time.Second), labels: []string{fmt.Sprintf("cpu%02d", i)}, }) } return values }, }, { name: "container_cpu_cfs_periods_total", help: "Number of elapsed enforcement period intervals.", valueType: prometheus.CounterValue, condition: func(s info.ContainerSpec) bool { return s.Cpu.Quota != 0 }, getValues: func(s *info.ContainerStats) metricValues { return metricValues{{value: float64(s.Cpu.CFS.Periods)}} }, }, { name: "container_cpu_cfs_throttled_periods_total", help: "Number of throttled period intervals.", valueType: prometheus.CounterValue, condition: func(s info.ContainerSpec) bool { return s.Cpu.Quota != 0 }, getValues: func(s *info.ContainerStats) metricValues { return metricValues{{value: float64(s.Cpu.CFS.ThrottledPeriods)}} }, }, { name: "container_cpu_cfs_throttled_seconds_total", help: "Total time duration the container has been throttled.", valueType: prometheus.CounterValue, condition: func(s info.ContainerSpec) bool { return s.Cpu.Quota != 0 }, getValues: func(s *info.ContainerStats) metricValues { return metricValues{{value: float64(s.Cpu.CFS.ThrottledTime) / float64(time.Second)}} }, }, { name: "container_memory_cache", help: "Number of bytes of page cache memory.", valueType: prometheus.GaugeValue, getValues: func(s *info.ContainerStats) metricValues { return metricValues{{value: float64(s.Memory.Cache)}} }, }, { name: "container_memory_rss", help: "Size of RSS in bytes.", valueType: prometheus.GaugeValue, getValues: func(s *info.ContainerStats) metricValues { return metricValues{{value: float64(s.Memory.RSS)}} }, }, { name: "container_memory_swap", help: "Container swap usage in bytes.", valueType: prometheus.GaugeValue, getValues: func(s *info.ContainerStats) metricValues { return metricValues{{value: float64(s.Memory.Swap)}} }, }, { name: "container_memory_failcnt", help: "Number of memory usage hits limits", valueType: prometheus.CounterValue, getValues: func(s *info.ContainerStats) metricValues { return metricValues{{value: float64(s.Memory.Failcnt)}} }, }, { name: "container_memory_usage_bytes", help: "Current memory usage in bytes.", valueType: prometheus.GaugeValue, getValues: func(s *info.ContainerStats) metricValues { return metricValues{{value: float64(s.Memory.Usage)}} }, }, { name: "container_memory_working_set_bytes", help: "Current working set in bytes.", valueType: prometheus.GaugeValue, getValues: func(s *info.ContainerStats) metricValues { return metricValues{{value: float64(s.Memory.WorkingSet)}} }, }, { name: "container_memory_failures_total", help: "Cumulative count of memory allocation failures.", valueType: prometheus.CounterValue, extraLabels: []string{"type", "scope"}, getValues: func(s *info.ContainerStats) metricValues { return metricValues{ { value: float64(s.Memory.ContainerData.Pgfault), labels: []string{"pgfault", "container"}, }, { value: float64(s.Memory.ContainerData.Pgmajfault), labels: []string{"pgmajfault", "container"}, }, { value: float64(s.Memory.HierarchicalData.Pgfault), labels: []string{"pgfault", "hierarchy"}, }, { value: float64(s.Memory.HierarchicalData.Pgmajfault), labels: []string{"pgmajfault", "hierarchy"}, }, } }, }, { name: "container_fs_inodes_free", help: "Number of available Inodes", valueType: prometheus.GaugeValue, extraLabels: []string{"device"}, getValues: func(s *info.ContainerStats) metricValues { return fsValues(s.Filesystem, func(fs *info.FsStats) float64 { return float64(fs.InodesFree) }) }, }, { name: "container_fs_inodes_total", help: "Number of Inodes", valueType: prometheus.GaugeValue, extraLabels: []string{"device"}, getValues: func(s *info.ContainerStats) metricValues { return fsValues(s.Filesystem, func(fs *info.FsStats) float64 { return float64(fs.Inodes) }) }, }, { name: "container_fs_limit_bytes", help: "Number of bytes that can be consumed by the container on this filesystem.", valueType: prometheus.GaugeValue, extraLabels: []string{"device"}, getValues: func(s *info.ContainerStats) metricValues { return fsValues(s.Filesystem, func(fs *info.FsStats) float64 { return float64(fs.Limit) }) }, }, { name: "container_fs_usage_bytes", help: "Number of bytes that are consumed by the container on this filesystem.", valueType: prometheus.GaugeValue, extraLabels: []string{"device"}, getValues: func(s *info.ContainerStats) metricValues { return fsValues(s.Filesystem, func(fs *info.FsStats) float64 { return float64(fs.Usage) }) }, }, { name: "container_fs_reads_total", help: "Cumulative count of reads completed", valueType: prometheus.CounterValue, extraLabels: []string{"device"}, getValues: func(s *info.ContainerStats) metricValues { return fsValues(s.Filesystem, func(fs *info.FsStats) float64 { return float64(fs.ReadsCompleted) }) }, }, { name: "container_fs_sector_reads_total", help: "Cumulative count of sector reads completed", valueType: prometheus.CounterValue, extraLabels: []string{"device"}, getValues: func(s *info.ContainerStats) metricValues { return fsValues(s.Filesystem, func(fs *info.FsStats) float64 { return float64(fs.SectorsRead) }) }, }, { name: "container_fs_reads_merged_total", help: "Cumulative count of reads merged", valueType: prometheus.CounterValue, extraLabels: []string{"device"}, getValues: func(s *info.ContainerStats) metricValues { return fsValues(s.Filesystem, func(fs *info.FsStats) float64 { return float64(fs.ReadsMerged) }) }, }, { name: "container_fs_read_seconds_total", help: "Cumulative count of seconds spent reading", valueType: prometheus.CounterValue, extraLabels: []string{"device"}, getValues: func(s *info.ContainerStats) metricValues { return fsValues(s.Filesystem, func(fs *info.FsStats) float64 { return float64(fs.ReadTime) / float64(time.Second) }) }, }, { name: "container_fs_writes_total", help: "Cumulative count of writes completed", valueType: prometheus.CounterValue, extraLabels: []string{"device"}, getValues: func(s *info.ContainerStats) metricValues { return fsValues(s.Filesystem, func(fs *info.FsStats) float64 { return float64(fs.WritesCompleted) }) }, }, { name: "container_fs_sector_writes_total", help: "Cumulative count of sector writes completed", valueType: prometheus.CounterValue, extraLabels: []string{"device"}, getValues: func(s *info.ContainerStats) metricValues { return fsValues(s.Filesystem, func(fs *info.FsStats) float64 { return float64(fs.SectorsWritten) }) }, }, { name: "container_fs_writes_merged_total", help: "Cumulative count of writes merged", valueType: prometheus.CounterValue, extraLabels: []string{"device"}, getValues: func(s *info.ContainerStats) metricValues { return fsValues(s.Filesystem, func(fs *info.FsStats) float64 { return float64(fs.WritesMerged) }) }, }, { name: "container_fs_write_seconds_total", help: "Cumulative count of seconds spent writing", valueType: prometheus.CounterValue, extraLabels: []string{"device"}, getValues: func(s *info.ContainerStats) metricValues { return fsValues(s.Filesystem, func(fs *info.FsStats) float64 { return float64(fs.WriteTime) / float64(time.Second) }) }, }, { name: "container_fs_io_current", help: "Number of I/Os currently in progress", valueType: prometheus.GaugeValue, extraLabels: []string{"device"}, getValues: func(s *info.ContainerStats) metricValues { return fsValues(s.Filesystem, func(fs *info.FsStats) float64 { return float64(fs.IoInProgress) }) }, }, { name: "container_fs_io_time_seconds_total", help: "Cumulative count of seconds spent doing I/Os", valueType: prometheus.CounterValue, extraLabels: []string{"device"}, getValues: func(s *info.ContainerStats) metricValues { return fsValues(s.Filesystem, func(fs *info.FsStats) float64 { return float64(float64(fs.IoTime) / float64(time.Second)) }) }, }, { name: "container_fs_io_time_weighted_seconds_total", help: "Cumulative weighted I/O time in seconds", valueType: prometheus.CounterValue, extraLabels: []string{"device"}, getValues: func(s *info.ContainerStats) metricValues { return fsValues(s.Filesystem, func(fs *info.FsStats) float64 { return float64(fs.WeightedIoTime) / float64(time.Second) }) }, }, { name: "container_network_receive_bytes_total", help: "Cumulative count of bytes received", valueType: prometheus.CounterValue, extraLabels: []string{"interface"}, getValues: func(s *info.ContainerStats) metricValues { values := make(metricValues, 0, len(s.Network.Interfaces)) for _, value := range s.Network.Interfaces { values = append(values, metricValue{ value: float64(value.RxBytes), labels: []string{value.Name}, }) } return values }, }, { name: "container_network_receive_packets_total", help: "Cumulative count of packets received", valueType: prometheus.CounterValue, extraLabels: []string{"interface"}, getValues: func(s *info.ContainerStats) metricValues { values := make(metricValues, 0, len(s.Network.Interfaces)) for _, value := range s.Network.Interfaces { values = append(values, metricValue{ value: float64(value.RxPackets), labels: []string{value.Name}, }) } return values }, }, { name: "container_network_receive_packets_dropped_total", help: "Cumulative count of packets dropped while receiving", valueType: prometheus.CounterValue, extraLabels: []string{"interface"}, getValues: func(s *info.ContainerStats) metricValues { values := make(metricValues, 0, len(s.Network.Interfaces)) for _, value := range s.Network.Interfaces { values = append(values, metricValue{ value: float64(value.RxDropped), labels: []string{value.Name}, }) } return values }, }, { name: "container_network_receive_errors_total", help: "Cumulative count of errors encountered while receiving", valueType: prometheus.CounterValue, extraLabels: []string{"interface"}, getValues: func(s *info.ContainerStats) metricValues { values := make(metricValues, 0, len(s.Network.Interfaces)) for _, value := range s.Network.Interfaces { values = append(values, metricValue{ value: float64(value.RxErrors), labels: []string{value.Name}, }) } return values }, }, { name: "container_network_transmit_bytes_total", help: "Cumulative count of bytes transmitted", valueType: prometheus.CounterValue, extraLabels: []string{"interface"}, getValues: func(s *info.ContainerStats) metricValues { values := make(metricValues, 0, len(s.Network.Interfaces)) for _, value := range s.Network.Interfaces { values = append(values, metricValue{ value: float64(value.TxBytes), labels: []string{value.Name}, }) } return values }, }, { name: "container_network_transmit_packets_total", help: "Cumulative count of packets transmitted", valueType: prometheus.CounterValue, extraLabels: []string{"interface"}, getValues: func(s *info.ContainerStats) metricValues { values := make(metricValues, 0, len(s.Network.Interfaces)) for _, value := range s.Network.Interfaces { values = append(values, metricValue{ value: float64(value.TxPackets), labels: []string{value.Name}, }) } return values }, }, { name: "container_network_transmit_packets_dropped_total", help: "Cumulative count of packets dropped while transmitting", valueType: prometheus.CounterValue, extraLabels: []string{"interface"}, getValues: func(s *info.ContainerStats) metricValues { values := make(metricValues, 0, len(s.Network.Interfaces)) for _, value := range s.Network.Interfaces { values = append(values, metricValue{ value: float64(value.TxDropped), labels: []string{value.Name}, }) } return values }, }, { name: "container_network_transmit_errors_total", help: "Cumulative count of errors encountered while transmitting", valueType: prometheus.CounterValue, extraLabels: []string{"interface"}, getValues: func(s *info.ContainerStats) metricValues { values := make(metricValues, 0, len(s.Network.Interfaces)) for _, value := range s.Network.Interfaces { values = append(values, metricValue{ value: float64(value.TxErrors), labels: []string{value.Name}, }) } return values }, }, { name: "container_tasks_state", help: "Number of tasks in given state", extraLabels: []string{"state"}, valueType: prometheus.GaugeValue, getValues: func(s *info.ContainerStats) metricValues { return metricValues{ { value: float64(s.TaskStats.NrSleeping), labels: []string{"sleeping"}, }, { value: float64(s.TaskStats.NrRunning), labels: []string{"running"}, }, { value: float64(s.TaskStats.NrStopped), labels: []string{"stopped"}, }, { value: float64(s.TaskStats.NrUninterruptible), labels: []string{"uninterruptible"}, }, { value: float64(s.TaskStats.NrIoWait), labels: []string{"iowaiting"}, }, } }, }, }, } return c } var ( versionInfoDesc = prometheus.NewDesc("cadvisor_version_info", "A metric with a constant '1' value labeled by kernel version, OS version, docker version, cadvisor version & cadvisor revision.", []string{"kernelVersion", "osVersion", "dockerVersion", "cadvisorVersion", "cadvisorRevision"}, nil) machineInfoCoresDesc = prometheus.NewDesc("machine_cpu_cores", "Number of CPU cores on the machine.", nil, nil) machineInfoMemoryDesc = prometheus.NewDesc("machine_memory_bytes", "Amount of memory installed on the machine.", nil, nil) ) // Describe describes all the metrics ever exported by cadvisor. It // implements prometheus.PrometheusCollector. func (c *PrometheusCollector) Describe(ch chan<- *prometheus.Desc) { c.errors.Describe(ch) for _, cm := range c.containerMetrics { ch <- cm.desc([]string{}) } ch <- versionInfoDesc ch <- machineInfoCoresDesc ch <- machineInfoMemoryDesc } // Collect fetches the stats from all containers and delivers them as // Prometheus metrics. It implements prometheus.PrometheusCollector. func (c *PrometheusCollector) Collect(ch chan<- prometheus.Metric) { c.errors.Set(0) c.collectMachineInfo(ch) c.collectVersionInfo(ch) c.collectContainersInfo(ch) c.errors.Collect(ch) } const ( // ContainerLabelPrefix is the prefix added to all container labels. ContainerLabelPrefix = "container_label_" // ContainerEnvPrefix is the prefix added to all env variable labels. ContainerEnvPrefix = "container_env_" // LabelID is the name of the id label. LabelID = "id" // LabelName is the name of the name label. LabelName = "name" // LabelImage is the name of the image label. LabelImage = "image" ) // DefaultContainerLabels implements ContainerLabelsFunc. It exports the // container name, first alias, image name as well as all its env and label // values. func DefaultContainerLabels(container *info.ContainerInfo) map[string]string { set := map[string]string{LabelID: container.Name} if len(container.Aliases) > 0 { set[LabelName] = container.Aliases[0] } if image := container.Spec.Image; len(image) > 0 { set[LabelImage] = image } for k, v := range container.Spec.Labels { set[ContainerLabelPrefix+k] = v } for k, v := range container.Spec.Envs { set[ContainerEnvPrefix+k] = v } return set } func (c *PrometheusCollector) collectContainersInfo(ch chan<- prometheus.Metric) { containers, err := c.infoProvider.SubcontainersInfo("/", &info.ContainerInfoRequest{NumStats: 1}) if err != nil { c.errors.Set(1) glog.Warningf("Couldn't get containers: %s", err) return } for _, container := range containers { labels, values := []string{}, []string{} for l, v := range c.containerLabelsFunc(container) { labels = append(labels, sanitizeLabelName(l)) values = append(values, v) } // Container spec desc := prometheus.NewDesc("container_start_time_seconds", "Start time of the container since unix epoch in seconds.", labels, nil) ch <- prometheus.MustNewConstMetric(desc, prometheus.GaugeValue, float64(container.Spec.CreationTime.Unix()), values...) if container.Spec.HasCpu { desc = prometheus.NewDesc("container_spec_cpu_period", "CPU period of the container.", labels, nil) ch <- prometheus.MustNewConstMetric(desc, prometheus.GaugeValue, float64(container.Spec.Cpu.Period), values...) if container.Spec.Cpu.Quota != 0 { desc = prometheus.NewDesc("container_spec_cpu_quota", "CPU quota of the container.", labels, nil) ch <- prometheus.MustNewConstMetric(desc, prometheus.GaugeValue, float64(container.Spec.Cpu.Quota), values...) } desc := prometheus.NewDesc("container_spec_cpu_shares", "CPU share of the container.", labels, nil) ch <- prometheus.MustNewConstMetric(desc, prometheus.GaugeValue, float64(container.Spec.Cpu.Limit), values...) } if container.Spec.HasMemory { desc := prometheus.NewDesc("container_spec_memory_limit_bytes", "Memory limit for the container.", labels, nil) ch <- prometheus.MustNewConstMetric(desc, prometheus.GaugeValue, specMemoryValue(container.Spec.Memory.Limit), values...) desc = prometheus.NewDesc("container_spec_memory_swap_limit_bytes", "Memory swap limit for the container.", labels, nil) ch <- prometheus.MustNewConstMetric(desc, prometheus.GaugeValue, specMemoryValue(container.Spec.Memory.SwapLimit), values...) } // Now for the actual metrics stats := container.Stats[0] for _, cm := range c.containerMetrics { if cm.condition != nil && !cm.condition(container.Spec) { continue } desc := cm.desc(labels) for _, metricValue := range cm.getValues(stats) { ch <- prometheus.MustNewConstMetric(desc, cm.valueType, float64(metricValue.value), append(values, metricValue.labels...)...) } } } } func (c *PrometheusCollector) collectVersionInfo(ch chan<- prometheus.Metric) { versionInfo, err := c.infoProvider.GetVersionInfo() if err != nil { c.errors.Set(1) glog.Warningf("Couldn't get version info: %s", err) return } ch <- prometheus.MustNewConstMetric(versionInfoDesc, prometheus.GaugeValue, 1, []string{versionInfo.KernelVersion, versionInfo.ContainerOsVersion, versionInfo.DockerVersion, versionInfo.CadvisorVersion, versionInfo.CadvisorRevision}...) } func (c *PrometheusCollector) collectMachineInfo(ch chan<- prometheus.Metric) { machineInfo, err := c.infoProvider.GetMachineInfo() if err != nil { c.errors.Set(1) glog.Warningf("Couldn't get machine info: %s", err) return } ch <- prometheus.MustNewConstMetric(machineInfoCoresDesc, prometheus.GaugeValue, float64(machineInfo.NumCores)) ch <- prometheus.MustNewConstMetric(machineInfoMemoryDesc, prometheus.GaugeValue, float64(machineInfo.MemoryCapacity)) } // Size after which we consider memory to be "unlimited". This is not // MaxInt64 due to rounding by the kernel. const maxMemorySize = uint64(1 << 62) func specMemoryValue(v uint64) float64 { if v > maxMemorySize { return 0 } return float64(v) } var invalidLabelCharRE = regexp.MustCompile(`[^a-zA-Z0-9_]`) // sanitizeLabelName replaces anything that doesn't match // client_label.LabelNameRE with an underscore. func sanitizeLabelName(name string) string { return invalidLabelCharRE.ReplaceAllString(name, "_") } cadvisor-0.25.0/metrics/prometheus_test.go000066400000000000000000000162021306035727200206450ustar00rootroot00000000000000// 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 metrics import ( "errors" "io/ioutil" "net/http" "net/http/httptest" "regexp" "strings" "testing" "time" info "github.com/google/cadvisor/info/v1" "github.com/prometheus/client_golang/prometheus" ) type testSubcontainersInfoProvider struct{} func (p testSubcontainersInfoProvider) GetVersionInfo() (*info.VersionInfo, error) { return &info.VersionInfo{ KernelVersion: "4.1.6-200.fc22.x86_64", ContainerOsVersion: "Fedora 22 (Twenty Two)", DockerVersion: "1.8.1", CadvisorVersion: "0.16.0", CadvisorRevision: "abcdef", }, nil } func (p testSubcontainersInfoProvider) GetMachineInfo() (*info.MachineInfo, error) { return &info.MachineInfo{ NumCores: 4, MemoryCapacity: 1024, }, nil } func (p testSubcontainersInfoProvider) SubcontainersInfo(string, *info.ContainerInfoRequest) ([]*info.ContainerInfo, error) { return []*info.ContainerInfo{ { ContainerReference: info.ContainerReference{ Name: "testcontainer", Aliases: []string{"testcontaineralias"}, }, Spec: info.ContainerSpec{ Image: "test", HasCpu: true, Cpu: info.CpuSpec{ Limit: 1000, Period: 100000, Quota: 10000, }, CreationTime: time.Unix(1257894000, 0), Labels: map[string]string{ "foo.label": "bar", }, Envs: map[string]string{ "foo+env": "prod", }, }, Stats: []*info.ContainerStats{ { Cpu: info.CpuStats{ Usage: info.CpuUsage{ Total: 1, PerCpu: []uint64{2, 3, 4, 5}, User: 6, System: 7, }, CFS: info.CpuCFS{ Periods: 723, ThrottledPeriods: 18, ThrottledTime: 1724314000, }, }, Memory: info.MemoryStats{ Usage: 8, WorkingSet: 9, ContainerData: info.MemoryStatsMemoryData{ Pgfault: 10, Pgmajfault: 11, }, HierarchicalData: info.MemoryStatsMemoryData{ Pgfault: 12, Pgmajfault: 13, }, Cache: 14, RSS: 15, Swap: 8192, }, Network: info.NetworkStats{ InterfaceStats: info.InterfaceStats{ Name: "eth0", RxBytes: 14, RxPackets: 15, RxErrors: 16, RxDropped: 17, TxBytes: 18, TxPackets: 19, TxErrors: 20, TxDropped: 21, }, Interfaces: []info.InterfaceStats{ { Name: "eth0", RxBytes: 14, RxPackets: 15, RxErrors: 16, RxDropped: 17, TxBytes: 18, TxPackets: 19, TxErrors: 20, TxDropped: 21, }, }, }, Filesystem: []info.FsStats{ { Device: "sda1", InodesFree: 524288, Inodes: 2097152, Limit: 22, Usage: 23, ReadsCompleted: 24, ReadsMerged: 25, SectorsRead: 26, ReadTime: 27, WritesCompleted: 28, WritesMerged: 39, SectorsWritten: 40, WriteTime: 41, IoInProgress: 42, IoTime: 43, WeightedIoTime: 44, }, { Device: "sda2", InodesFree: 262144, Inodes: 2097152, Limit: 37, Usage: 38, ReadsCompleted: 39, ReadsMerged: 40, SectorsRead: 41, ReadTime: 42, WritesCompleted: 43, WritesMerged: 44, SectorsWritten: 45, WriteTime: 46, IoInProgress: 47, IoTime: 48, WeightedIoTime: 49, }, }, TaskStats: info.LoadStats{ NrSleeping: 50, NrRunning: 51, NrStopped: 52, NrUninterruptible: 53, NrIoWait: 54, }, }, }, }, }, nil } var ( includeRe = regexp.MustCompile(`^(?:(?:# HELP |# TYPE )?container_|cadvisor_version_info\{)`) ignoreRe = regexp.MustCompile(`^container_last_seen\{`) ) func TestPrometheusCollector(t *testing.T) { c := NewPrometheusCollector(testSubcontainersInfoProvider{}, func(container *info.ContainerInfo) map[string]string { s := DefaultContainerLabels(container) s["zone.name"] = "hello" return s }) prometheus.MustRegister(c) defer prometheus.Unregister(c) testPrometheusCollector(t, c, "testdata/prometheus_metrics") } func testPrometheusCollector(t *testing.T, c *PrometheusCollector, metricsFile string) { rw := httptest.NewRecorder() prometheus.Handler().ServeHTTP(rw, &http.Request{}) wantMetrics, err := ioutil.ReadFile(metricsFile) if err != nil { t.Fatalf("unable to read input test file %s", metricsFile) } wantLines := strings.Split(string(wantMetrics), "\n") gotLines := strings.Split(string(rw.Body.String()), "\n") // Until the Prometheus Go client library offers better testability // (https://github.com/prometheus/client_golang/issues/58), we simply compare // verbatim text-format metrics outputs, but ignore certain metric lines // whose value depends on the current time or local circumstances. for i, want := range wantLines { if !includeRe.MatchString(want) || ignoreRe.MatchString(want) { continue } if want != gotLines[i] { t.Fatalf("unexpected metric line\nwant: %s\nhave: %s", want, gotLines[i]) } } } type erroringSubcontainersInfoProvider struct { successfulProvider testSubcontainersInfoProvider shouldFail bool } func (p *erroringSubcontainersInfoProvider) GetVersionInfo() (*info.VersionInfo, error) { if p.shouldFail { return nil, errors.New("Oops 1") } return p.successfulProvider.GetVersionInfo() } func (p *erroringSubcontainersInfoProvider) GetMachineInfo() (*info.MachineInfo, error) { if p.shouldFail { return nil, errors.New("Oops 2") } return p.successfulProvider.GetMachineInfo() } func (p *erroringSubcontainersInfoProvider) SubcontainersInfo( a string, r *info.ContainerInfoRequest) ([]*info.ContainerInfo, error) { if p.shouldFail { return []*info.ContainerInfo{}, errors.New("Oops 3") } return p.successfulProvider.SubcontainersInfo(a, r) } func TestPrometheusCollector_scrapeFailure(t *testing.T) { provider := &erroringSubcontainersInfoProvider{ successfulProvider: testSubcontainersInfoProvider{}, shouldFail: true, } c := NewPrometheusCollector(provider, func(container *info.ContainerInfo) map[string]string { s := DefaultContainerLabels(container) s["zone.name"] = "hello" return s }) prometheus.MustRegister(c) defer prometheus.Unregister(c) testPrometheusCollector(t, c, "testdata/prometheus_metrics_failure") provider.shouldFail = false testPrometheusCollector(t, c, "testdata/prometheus_metrics") } cadvisor-0.25.0/metrics/testdata/000077500000000000000000000000001306035727200166745ustar00rootroot00000000000000cadvisor-0.25.0/metrics/testdata/prometheus_metrics000066400000000000000000000505051306035727200225450ustar00rootroot00000000000000# HELP cadvisor_version_info A metric with a constant '1' value labeled by kernel version, OS version, docker version, cadvisor version & cadvisor revision. # TYPE cadvisor_version_info gauge cadvisor_version_info{cadvisorRevision="abcdef",cadvisorVersion="0.16.0",dockerVersion="1.8.1",kernelVersion="4.1.6-200.fc22.x86_64",osVersion="Fedora 22 (Twenty Two)"} 1 # HELP container_cpu_cfs_periods_total Number of elapsed enforcement period intervals. # TYPE container_cpu_cfs_periods_total counter container_cpu_cfs_periods_total{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 723 # HELP container_cpu_cfs_throttled_periods_total Number of throttled period intervals. # TYPE container_cpu_cfs_throttled_periods_total counter container_cpu_cfs_throttled_periods_total{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 18 # HELP container_cpu_cfs_throttled_seconds_total Total time duration the container has been throttled. # TYPE container_cpu_cfs_throttled_seconds_total counter container_cpu_cfs_throttled_seconds_total{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 1.724314 # HELP container_cpu_system_seconds_total Cumulative system cpu time consumed in seconds. # TYPE container_cpu_system_seconds_total counter container_cpu_system_seconds_total{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 7e-09 # HELP container_cpu_usage_seconds_total Cumulative cpu time consumed per cpu in seconds. # TYPE container_cpu_usage_seconds_total counter container_cpu_usage_seconds_total{container_env_foo_env="prod",container_label_foo_label="bar",cpu="cpu00",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 2e-09 container_cpu_usage_seconds_total{container_env_foo_env="prod",container_label_foo_label="bar",cpu="cpu01",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 3e-09 container_cpu_usage_seconds_total{container_env_foo_env="prod",container_label_foo_label="bar",cpu="cpu02",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 4e-09 container_cpu_usage_seconds_total{container_env_foo_env="prod",container_label_foo_label="bar",cpu="cpu03",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 5e-09 # HELP container_cpu_user_seconds_total Cumulative user cpu time consumed in seconds. # TYPE container_cpu_user_seconds_total counter container_cpu_user_seconds_total{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 6e-09 # HELP container_fs_inodes_free Number of available Inodes # TYPE container_fs_inodes_free gauge container_fs_inodes_free{container_env_foo_env="prod",container_label_foo_label="bar",device="sda1",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 524288 container_fs_inodes_free{container_env_foo_env="prod",container_label_foo_label="bar",device="sda2",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 262144 # HELP container_fs_inodes_total Number of Inodes # TYPE container_fs_inodes_total gauge container_fs_inodes_total{container_env_foo_env="prod",container_label_foo_label="bar",device="sda1",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 2.097152e+06 container_fs_inodes_total{container_env_foo_env="prod",container_label_foo_label="bar",device="sda2",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 2.097152e+06 # HELP container_fs_io_current Number of I/Os currently in progress # TYPE container_fs_io_current gauge container_fs_io_current{container_env_foo_env="prod",container_label_foo_label="bar",device="sda1",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 42 container_fs_io_current{container_env_foo_env="prod",container_label_foo_label="bar",device="sda2",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 47 # HELP container_fs_io_time_seconds_total Cumulative count of seconds spent doing I/Os # TYPE container_fs_io_time_seconds_total counter container_fs_io_time_seconds_total{container_env_foo_env="prod",container_label_foo_label="bar",device="sda1",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 4.3e-08 container_fs_io_time_seconds_total{container_env_foo_env="prod",container_label_foo_label="bar",device="sda2",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 4.8e-08 # HELP container_fs_io_time_weighted_seconds_total Cumulative weighted I/O time in seconds # TYPE container_fs_io_time_weighted_seconds_total counter container_fs_io_time_weighted_seconds_total{container_env_foo_env="prod",container_label_foo_label="bar",device="sda1",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 4.4e-08 container_fs_io_time_weighted_seconds_total{container_env_foo_env="prod",container_label_foo_label="bar",device="sda2",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 4.9e-08 # HELP container_fs_limit_bytes Number of bytes that can be consumed by the container on this filesystem. # TYPE container_fs_limit_bytes gauge container_fs_limit_bytes{container_env_foo_env="prod",container_label_foo_label="bar",device="sda1",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 22 container_fs_limit_bytes{container_env_foo_env="prod",container_label_foo_label="bar",device="sda2",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 37 # HELP container_fs_read_seconds_total Cumulative count of seconds spent reading # TYPE container_fs_read_seconds_total counter container_fs_read_seconds_total{container_env_foo_env="prod",container_label_foo_label="bar",device="sda1",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 2.7e-08 container_fs_read_seconds_total{container_env_foo_env="prod",container_label_foo_label="bar",device="sda2",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 4.2e-08 # HELP container_fs_reads_merged_total Cumulative count of reads merged # TYPE container_fs_reads_merged_total counter container_fs_reads_merged_total{container_env_foo_env="prod",container_label_foo_label="bar",device="sda1",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 25 container_fs_reads_merged_total{container_env_foo_env="prod",container_label_foo_label="bar",device="sda2",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 40 # HELP container_fs_reads_total Cumulative count of reads completed # TYPE container_fs_reads_total counter container_fs_reads_total{container_env_foo_env="prod",container_label_foo_label="bar",device="sda1",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 24 container_fs_reads_total{container_env_foo_env="prod",container_label_foo_label="bar",device="sda2",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 39 # HELP container_fs_sector_reads_total Cumulative count of sector reads completed # TYPE container_fs_sector_reads_total counter container_fs_sector_reads_total{container_env_foo_env="prod",container_label_foo_label="bar",device="sda1",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 26 container_fs_sector_reads_total{container_env_foo_env="prod",container_label_foo_label="bar",device="sda2",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 41 # HELP container_fs_sector_writes_total Cumulative count of sector writes completed # TYPE container_fs_sector_writes_total counter container_fs_sector_writes_total{container_env_foo_env="prod",container_label_foo_label="bar",device="sda1",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 40 container_fs_sector_writes_total{container_env_foo_env="prod",container_label_foo_label="bar",device="sda2",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 45 # HELP container_fs_usage_bytes Number of bytes that are consumed by the container on this filesystem. # TYPE container_fs_usage_bytes gauge container_fs_usage_bytes{container_env_foo_env="prod",container_label_foo_label="bar",device="sda1",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 23 container_fs_usage_bytes{container_env_foo_env="prod",container_label_foo_label="bar",device="sda2",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 38 # HELP container_fs_write_seconds_total Cumulative count of seconds spent writing # TYPE container_fs_write_seconds_total counter container_fs_write_seconds_total{container_env_foo_env="prod",container_label_foo_label="bar",device="sda1",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 4.1e-08 container_fs_write_seconds_total{container_env_foo_env="prod",container_label_foo_label="bar",device="sda2",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 4.6e-08 # HELP container_fs_writes_merged_total Cumulative count of writes merged # TYPE container_fs_writes_merged_total counter container_fs_writes_merged_total{container_env_foo_env="prod",container_label_foo_label="bar",device="sda1",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 39 container_fs_writes_merged_total{container_env_foo_env="prod",container_label_foo_label="bar",device="sda2",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 44 # HELP container_fs_writes_total Cumulative count of writes completed # TYPE container_fs_writes_total counter container_fs_writes_total{container_env_foo_env="prod",container_label_foo_label="bar",device="sda1",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 28 container_fs_writes_total{container_env_foo_env="prod",container_label_foo_label="bar",device="sda2",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 43 # HELP container_last_seen Last time a container was seen by the exporter # TYPE container_last_seen gauge container_last_seen{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 1.426203694e+09 # HELP container_memory_cache Number of bytes of page cache memory. # TYPE container_memory_cache gauge container_memory_cache{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 14 # HELP container_memory_failcnt Number of memory usage hits limits # TYPE container_memory_failcnt counter container_memory_failcnt{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 0 # HELP container_memory_failures_total Cumulative count of memory allocation failures. # TYPE container_memory_failures_total counter container_memory_failures_total{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",name="testcontaineralias",scope="container",type="pgfault",zone_name="hello"} 10 container_memory_failures_total{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",name="testcontaineralias",scope="container",type="pgmajfault",zone_name="hello"} 11 container_memory_failures_total{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",name="testcontaineralias",scope="hierarchy",type="pgfault",zone_name="hello"} 12 container_memory_failures_total{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",name="testcontaineralias",scope="hierarchy",type="pgmajfault",zone_name="hello"} 13 # HELP container_memory_rss Size of RSS in bytes. # TYPE container_memory_rss gauge container_memory_rss{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 15 # HELP container_memory_swap Container swap usage in bytes. # TYPE container_memory_swap gauge container_memory_swap{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 8192 # HELP container_memory_usage_bytes Current memory usage in bytes. # TYPE container_memory_usage_bytes gauge container_memory_usage_bytes{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 8 # HELP container_memory_working_set_bytes Current working set in bytes. # TYPE container_memory_working_set_bytes gauge container_memory_working_set_bytes{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 9 # HELP container_network_receive_bytes_total Cumulative count of bytes received # TYPE container_network_receive_bytes_total counter container_network_receive_bytes_total{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",interface="eth0",name="testcontaineralias",zone_name="hello"} 14 # HELP container_network_receive_errors_total Cumulative count of errors encountered while receiving # TYPE container_network_receive_errors_total counter container_network_receive_errors_total{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",interface="eth0",name="testcontaineralias",zone_name="hello"} 16 # HELP container_network_receive_packets_dropped_total Cumulative count of packets dropped while receiving # TYPE container_network_receive_packets_dropped_total counter container_network_receive_packets_dropped_total{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",interface="eth0",name="testcontaineralias",zone_name="hello"} 17 # HELP container_network_receive_packets_total Cumulative count of packets received # TYPE container_network_receive_packets_total counter container_network_receive_packets_total{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",interface="eth0",name="testcontaineralias",zone_name="hello"} 15 # HELP container_network_transmit_bytes_total Cumulative count of bytes transmitted # TYPE container_network_transmit_bytes_total counter container_network_transmit_bytes_total{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",interface="eth0",name="testcontaineralias",zone_name="hello"} 18 # HELP container_network_transmit_errors_total Cumulative count of errors encountered while transmitting # TYPE container_network_transmit_errors_total counter container_network_transmit_errors_total{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",interface="eth0",name="testcontaineralias",zone_name="hello"} 20 # HELP container_network_transmit_packets_dropped_total Cumulative count of packets dropped while transmitting # TYPE container_network_transmit_packets_dropped_total counter container_network_transmit_packets_dropped_total{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",interface="eth0",name="testcontaineralias",zone_name="hello"} 21 # HELP container_network_transmit_packets_total Cumulative count of packets transmitted # TYPE container_network_transmit_packets_total counter container_network_transmit_packets_total{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",interface="eth0",name="testcontaineralias",zone_name="hello"} 19 # HELP container_scrape_error 1 if there was an error while getting container metrics, 0 otherwise # TYPE container_scrape_error gauge container_scrape_error 0 # HELP container_spec_cpu_period CPU period of the container. # TYPE container_spec_cpu_period gauge container_spec_cpu_period{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 100000 # HELP container_spec_cpu_quota CPU quota of the container. # TYPE container_spec_cpu_quota gauge container_spec_cpu_quota{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 10000 # HELP container_spec_cpu_shares CPU share of the container. # TYPE container_spec_cpu_shares gauge container_spec_cpu_shares{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 1000 # HELP container_start_time_seconds Start time of the container since unix epoch in seconds. # TYPE container_start_time_seconds gauge container_start_time_seconds{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",name="testcontaineralias",zone_name="hello"} 1.257894e+09 # HELP container_tasks_state Number of tasks in given state # TYPE container_tasks_state gauge container_tasks_state{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",name="testcontaineralias",state="iowaiting",zone_name="hello"} 54 container_tasks_state{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",name="testcontaineralias",state="running",zone_name="hello"} 51 container_tasks_state{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",name="testcontaineralias",state="sleeping",zone_name="hello"} 50 container_tasks_state{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",name="testcontaineralias",state="stopped",zone_name="hello"} 52 container_tasks_state{container_env_foo_env="prod",container_label_foo_label="bar",id="testcontainer",image="test",name="testcontaineralias",state="uninterruptible",zone_name="hello"} 53 # HELP http_request_duration_microseconds The HTTP request latencies in microseconds. # TYPE http_request_duration_microseconds summary http_request_duration_microseconds{handler="prometheus",quantile="0.5"} 0 http_request_duration_microseconds{handler="prometheus",quantile="0.9"} 0 http_request_duration_microseconds{handler="prometheus",quantile="0.99"} 0 http_request_duration_microseconds_sum{handler="prometheus"} 0 http_request_duration_microseconds_count{handler="prometheus"} 0 # HELP http_request_size_bytes The HTTP request sizes in bytes. # TYPE http_request_size_bytes summary http_request_size_bytes{handler="prometheus",quantile="0.5"} 0 http_request_size_bytes{handler="prometheus",quantile="0.9"} 0 http_request_size_bytes{handler="prometheus",quantile="0.99"} 0 http_request_size_bytes_sum{handler="prometheus"} 0 http_request_size_bytes_count{handler="prometheus"} 0 # HELP http_response_size_bytes The HTTP response sizes in bytes. # TYPE http_response_size_bytes summary http_response_size_bytes{handler="prometheus",quantile="0.5"} 0 http_response_size_bytes{handler="prometheus",quantile="0.9"} 0 http_response_size_bytes{handler="prometheus",quantile="0.99"} 0 http_response_size_bytes_sum{handler="prometheus"} 0 http_response_size_bytes_count{handler="prometheus"} 0 # HELP machine_cpu_cores Number of CPU cores on the machine. # TYPE machine_cpu_cores gauge machine_cpu_cores 4 # HELP machine_memory_bytes Amount of memory installed on the machine. # TYPE machine_memory_bytes gauge machine_memory_bytes 1024 # HELP process_cpu_seconds_total Total user and system CPU time spent in seconds. # TYPE process_cpu_seconds_total counter process_cpu_seconds_total 0 # HELP process_goroutines Number of goroutines that currently exist. # TYPE process_goroutines gauge process_goroutines 16 # HELP process_max_fds Maximum number of open file descriptors. # TYPE process_max_fds gauge process_max_fds 1024 # HELP process_open_fds Number of open file descriptors. # TYPE process_open_fds gauge process_open_fds 4 # HELP process_resident_memory_bytes Resident memory size in bytes. # TYPE process_resident_memory_bytes gauge process_resident_memory_bytes 7.74144e+06 # HELP process_start_time_seconds Start time of the process since unix epoch in seconds. # TYPE process_start_time_seconds gauge process_start_time_seconds 1.42620369439e+09 # HELP process_virtual_memory_bytes Virtual memory size in bytes. # TYPE process_virtual_memory_bytes gauge process_virtual_memory_bytes 1.16420608e+08 cadvisor-0.25.0/metrics/testdata/prometheus_metrics_failure000066400000000000000000000002401306035727200242430ustar00rootroot00000000000000# HELP container_scrape_error 1 if there was an error while getting container metrics, 0 otherwise # TYPE container_scrape_error gauge container_scrape_error 1 cadvisor-0.25.0/pages/000077500000000000000000000000001306035727200145145ustar00rootroot00000000000000cadvisor-0.25.0/pages/assets/000077500000000000000000000000001306035727200160165ustar00rootroot00000000000000cadvisor-0.25.0/pages/assets/html/000077500000000000000000000000001306035727200167625ustar00rootroot00000000000000cadvisor-0.25.0/pages/assets/html/containers.html000066400000000000000000000224751306035727200220270ustar00rootroot00000000000000 cAdvisor - {{.DisplayName}}

{{.DisplayName}}

    {{range $parentContainer := .ParentContainers}}
  1. {{$parentContainer.Text}}
    2. {{end}}
{{if .IsRoot}}

Docker Containers

{{end}} {{if .Subcontainers}}

Subcontainers

{{range $subcontainer := .Subcontainers}} {{$subcontainer.Text}} {{end}}
{{end}} {{if .DockerStatus}}

Driver Status

    {{range $dockerstatus := .DockerStatus}}
  • {{$dockerstatus.Key}} {{$dockerstatus.Value}}
    • {{end}} {{if .DockerDriverStatus}}
  • Storage
      {{range $driverstatus := .DockerDriverStatus}}
    • {{$driverstatus.Key}} {{$driverstatus.Value}}
      • {{end}}
{{end}}
{{end}} {{if .DockerImages}}

Images



{{end}} {{if .ResourcesAvailable}}

Isolation

{{if .CpuAvailable}}
  • CPU
    • {{if .Spec.Cpu.Limit}}
  • Shares {{printShares .Spec.Cpu.Limit}} shares
    • {{end}} {{if .Spec.Cpu.MaxLimit}}
  • Max Limit {{printCores .Spec.Cpu.MaxLimit}} cores
    • {{end}} {{if .Spec.Cpu.Mask}}
  • Allowed Cores {{printMask .Spec.Cpu.Mask .MachineInfo.NumCores}}
    • {{end}}
{{end}} {{if .MemoryAvailable}}
  • Memory
    • {{if .Spec.Memory.Reservation}}
  • Reservation {{printSize .Spec.Memory.Reservation}} {{printUnit .Spec.Memory.Reservation}}
    • {{end}} {{if .Spec.Memory.Limit}}
  • Limit {{printSize .Spec.Memory.Limit}} {{printUnit .Spec.Memory.Limit}}
    • {{end}} {{if .Spec.Memory.SwapLimit}}
  • Swap Limit {{printSize .Spec.Memory.SwapLimit}} {{printUnit .Spec.Memory.SwapLimit}}
    • {{end}}
{{end}}

Usage

Overview

Processes

{{if .CpuAvailable}}

CPU

Total Usage

Usage per Core

Usage Breakdown

{{end}} {{if .MemoryAvailable}}

Memory

Total Usage


Usage Breakdown

Hot Memory
Cold Memory
{{end}} {{if .NetworkAvailable}}

Network

Throughput

Errors

{{end}} {{if .FsAvailable}}

Filesystem

{{end}} {{if .CustomMetricsAvailable}}

Application Metrics

{{end}} {{if .SubcontainersAvailable}}

Subcontainers

Top CPU Usage:

Top Memory Usage:

{{end}}
{{end}}
cadvisor-0.25.0/pages/assets/js/000077500000000000000000000000001306035727200164325ustar00rootroot00000000000000cadvisor-0.25.0/pages/assets/js/containers.js000066400000000000000000001031021306035727200211320ustar00rootroot00000000000000// 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. function humanize(num, size, units) { var unit; for (unit = units.pop(); units.length && num >= size; unit = units.pop()) { num /= size; } return [num, unit]; } // Following the IEC naming convention function humanizeIEC(num) { var ret = humanize(num, 1024, ['TiB', 'GiB', 'MiB', 'KiB', 'B']); return ret[0].toFixed(2) + ' ' + ret[1]; } // Following the Metric naming convention function humanizeMetric(num) { var ret = humanize(num, 1000, ['TB', 'GB', 'MB', 'KB', 'Bytes']); return ret[0].toFixed(2) + ' ' + ret[1]; } // Draw a table. function drawTable( seriesTitles, titleTypes, data, elementId, numPages, sortIndex) { var dataTable = new google.visualization.DataTable(); for (var i = 0; i < seriesTitles.length; i++) { dataTable.addColumn(titleTypes[i], seriesTitles[i]); } dataTable.addRows(data); if (!(elementId in window.charts)) { window.charts[elementId] = new google.visualization.Table(document.getElementById(elementId)); } var cssClassNames = { 'headerRow': '', 'tableRow': 'table-row', 'oddTableRow': 'table-row' }; var opts = { alternatingRowStyle: true, page: 'enable', pageSize: numPages, allowHtml: true, sortColumn: sortIndex, sortAscending: false, cssClassNames: cssClassNames }; window.charts[elementId].draw(dataTable, opts); } // Draw a line chart. function drawLineChart(seriesTitles, data, elementId, unit) { var min = Infinity; var max = -Infinity; for (var i = 0; i < data.length; i++) { // Convert the first column to a Date. if (data[i] != null) { data[i][0] = new Date(data[i][0]); } // Find min, max. for (var j = 1; j < data[i].length; j++) { var val = data[i][j]; if (val < min) { min = val; } if (val > max) { max = val; } } } // We don't want to show any values less than 0 so cap the min value at that. // At the same time, show 10% of the graph below the min value if we can. var minWindow = min - (max - min) / 10; if (minWindow < 0) { minWindow = 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. if (!(elementId in window.charts)) { window.charts[elementId] = new google.visualization.LineChart(document.getElementById(elementId)); } // TODO(vmarmol): Look into changing the view window to get a smoother // animation. var opts = { curveType: 'function', height: 300, legend: {position: 'none'}, focusTarget: 'category', vAxis: { title: unit, viewWindow: { min: minWindow, } }, legend: { position: 'bottom' } }; // If the whole data series has the same value, try to center it in the chart. if (min == max) { opts.vAxis.viewWindow.max = 1.1 * max; opts.vAxis.viewWindow.min = 0.9 * max; } window.charts[elementId].draw(dataTable, opts); } // Gets the length of the interval in nanoseconds. function getInterval(current, previous) { var cur = new Date(current); var prev = new Date(previous); // ms -> ns. return (cur.getTime() - prev.getTime()) * 1000000; } // Checks if the specified stats include the specified resource. function hasResource(stats, resource) { return stats.stats.length > 0 && stats.stats[0][resource]; } // Checks if all containers in provided list include the specified resource. function hasResourceForAll(containerInfos, resource) { if (containerInfos.length === 0) { return false; } for (var i = 0; i < containerInfos.length; i++) { if (!hasResource(containerInfos[i], resource)) { return false; } } return true; } // Draw a set of gauges. Data is comprised of an array of arrays with two // elements: // a string label and a numeric value for the gauge. function drawGauges(elementId, gauges) { gauges.unshift(['Label', 'Value']); // Create and populate the data table. var data = google.visualization.arrayToDataTable(gauges); // Create and draw the visualization. var options = { height: 100, 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(rootDir, callback) { $.getJSON(rootDir + 'api/v1.0/machine', function(data) { callback(data); }); } // Get ps info. function getProcessInfo(rootDir, containerName, callback) { $.getJSON(rootDir + 'api/v2.0/ps' + containerName) .done(function(data) { callback(data); }) .fail(function(jqhxr, textStatus, error) { callback([]); }); } // Get the container stats for the specified container. function getStats(rootDir, containerName, callback) { // Request 60s of container history and no samples. var request = JSON.stringify({ // Update main.statsRequestedByUI while updating "num_stats" here. 'num_stats': 60, 'num_samples': 0 }); $.when( $.post(rootDir + 'api/v1.0/containers' + containerName, request), $.post(rootDir + 'api/v1.1/subcontainers' + containerName, request)) .done(function(containersResp, subcontainersResp) { callback(containersResp[0], subcontainersResp[0]); }); } // Draw the graph for CPU usage. function drawCpuTotalUsage(elementId, machineInfo, stats) { if (stats.spec.has_cpu && !hasResource(stats, 'cpu')) { return; } 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]; var intervalNs = getInterval(cur.timestamp, prev.timestamp); var elements = []; elements.push(cur.timestamp); elements.push((cur.cpu.usage.total - prev.cpu.usage.total) / intervalNs); data.push(elements); } drawLineChart(titles, data, elementId, 'Cores'); } // Draw the graph for CPU load. function drawCpuLoad(elementId, machineInfo, stats) { var titles = ['Time', 'Average']; var data = []; for (var i = 1; i < stats.stats.length; i++) { var cur = stats.stats[i]; var elements = []; elements.push(cur.timestamp); elements.push(cur.cpu.load_average / 1000); data.push(elements); } drawLineChart(titles, data, elementId, 'Runnable threads'); } // Draw the graph for per-core CPU usage. function drawCpuPerCoreUsage(elementId, machineInfo, stats) { if (stats.spec.has_cpu && !hasResource(stats, 'cpu')) { return; } // 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 intervalNs = getInterval(cur.timestamp, prev.timestamp); var elements = []; elements.push(cur.timestamp); for (var j = 0; j < machineInfo.num_cores; j++) { elements.push( (cur.cpu.usage.per_cpu_usage[j] - prev.cpu.usage.per_cpu_usage[j]) / intervalNs); } data.push(elements); } drawLineChart(titles, data, elementId, 'Cores'); } // Draw the graph for CPU usage breakdown. function drawCpuUsageBreakdown(elementId, machineInfo, containerInfo) { if (containerInfo.spec.has_cpu && !hasResource(containerInfo, 'cpu')) { return; } 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]; var intervalNs = getInterval(cur.timestamp, prev.timestamp); var elements = []; elements.push(cur.timestamp); elements.push((cur.cpu.usage.user - prev.cpu.usage.user) / intervalNs); elements.push( (cur.cpu.usage.system - prev.cpu.usage.system) / intervalNs); data.push(elements); } drawLineChart(titles, data, elementId, 'Cores'); } // Return chart titles and data from an array of subcontainerInfos, using the // passed dataFn to return the individual data points. function getSubcontainerChartData(subcontainerInfos, dataFn) { var titles = ['Time']; var data = []; for (var i = 0; i < subcontainerInfos.length; i++) { titles.push(subcontainerInfos[i].name); for (var j = 1; j < subcontainerInfos[i].stats.length; j++) { var cur = subcontainerInfos[i].stats[j]; var prev = subcontainerInfos[i].stats[j - 1]; // Generate a sparse array with timestamp at index zero and data point at // index i+1, to be used as a DataTable row. var elements = [cur.timestamp]; subcontainerInfos.forEach(function() { elements.push(null); }); elements[i+1] = dataFn(cur, prev); data.push(elements); } } return { titles: titles, data: data, } } // Draw the graph for per-subcontainer CPU usage. function drawCpuPerSubcontainerUsage(elementId, subcontainerInfos) { if (!hasResourceForAll(subcontainerInfos, 'cpu')) { return; } var chartData = getSubcontainerChartData(subcontainerInfos, function(cur, prev) { var intervalNs = getInterval(cur.timestamp, prev.timestamp); return (cur.cpu.usage.total - prev.cpu.usage.total) / intervalNs; }); drawLineChart(chartData.titles, chartData.data, elementId, 'Cores'); } // Draw the graph for per-subcontainer memory usage. function drawMemoryPerSubcontainerUsage(elementId, subcontainerInfos) { if (!hasResourceForAll(subcontainerInfos, 'memory')) { return; } var chartData = getSubcontainerChartData(subcontainerInfos, function(cur, prev) { return cur.memory.usage / oneMegabyte; }); drawLineChart(chartData.titles, chartData.data, elementId, 'Megabytes'); } // Draw the gauges for overall resource usage. function drawOverallUsage(elementId, machineInfo, containerInfo) { var cur = containerInfo.stats[containerInfo.stats.length - 1]; var gauges = []; var cpuUsage = 0; if (containerInfo.spec.has_cpu && containerInfo.stats.length >= 2) { var prev = containerInfo.stats[containerInfo.stats.length - 2]; var rawUsage = cur.cpu.usage.total - prev.cpu.usage.total; var intervalNs = getInterval(cur.timestamp, prev.timestamp); // Convert to millicores and take the percentage cpuUsage = Math.round(((rawUsage / intervalNs) / machineInfo.num_cores) * 100); if (cpuUsage > 100) { cpuUsage = 100; } gauges.push(['CPU', cpuUsage]); } var memoryUsage = 0; if (containerInfo.spec.has_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); gauges.push(['Memory', memoryUsage]); } var numGauges = gauges.length; if (cur.filesystem) { for (var i = 0; i < cur.filesystem.length; i++) { var data = cur.filesystem[i]; var totalUsage = Math.floor((data.usage * 100.0) / data.capacity); var els = window.cadvisor.fsUsage.elements[data.device]; // Update the gauges in the right order. gauges[numGauges + els.index] = ['FS #' + (els.index + 1), totalUsage]; } // Limit the number of filesystem gauges displayed to 5. // 'Filesystem details' section still shows information for all filesystems. var max_gauges = numGauges + 5; if (gauges.length > max_gauges) { gauges = gauges.slice(0, max_gauges); } } drawGauges(elementId, gauges); } var oneMegabyte = 1024 * 1024; var oneGigabyte = 1024 * oneMegabyte; function drawMemoryUsage(elementId, machineInfo, containerInfo) { if (containerInfo.spec.has_memory && !hasResource(containerInfo, 'memory')) { return; } var titles = ['Time', 'Total', 'Hot']; var data = []; for (var i = 0; i < containerInfo.stats.length; i++) { var cur = containerInfo.stats[i]; var elements = []; elements.push(cur.timestamp); elements.push(cur.memory.usage / oneMegabyte); elements.push(cur.memory.working_set / oneMegabyte); data.push(elements); } // Get the memory limit, saturate to the machine size. var memory_limit = machineInfo.memory_capacity; if (containerInfo.spec.memory.limit && (containerInfo.spec.memory.limit < memory_limit)) { memory_limit = containerInfo.spec.memory.limit; } // Updating the progress bar. var cur = containerInfo.stats[containerInfo.stats.length - 1]; var hotMemory = Math.floor((cur.memory.working_set * 100.0) / memory_limit); var totalMemory = Math.floor((cur.memory.usage * 100.0) / memory_limit); var coldMemory = totalMemory - hotMemory; $('#progress-hot-memory').width(hotMemory + '%'); $('#progress-cold-memory').width(coldMemory + '%'); $('#memory-text') .text( humanizeIEC(cur.memory.usage) + ' / ' + humanizeIEC(memory_limit) + ' (' + totalMemory + '%)'); drawLineChart(titles, data, elementId, 'Megabytes'); } // Get the index of the interface with the specified name. function getNetworkInterfaceIndex(interfaceName, interfaces) { for (var i = 0; i < interfaces.length; i++) { if (interfaces[i].name == interfaceName) { return i; } } return -1; } // Draw the graph for network tx/rx bytes. function drawNetworkBytes(elementId, machineInfo, stats) { if (stats.spec.has_network && !hasResource(stats, 'network')) { return; } // Get interface index. var interfaceIndex = -1; if (stats.stats.length > 0) { interfaceIndex = getNetworkInterfaceIndex( window.cadvisor.network.interface, stats.stats[0].network.interfaces); } if (interfaceIndex < 0) { console.log( 'Unable to find interface"', interfaceName, '" in ', stats.stats.network); return; } var titles = ['Time', 'Tx bytes', 'Rx bytes']; var data = []; for (var i = 1; i < stats.stats.length; i++) { var cur = stats.stats[i]; var prev = stats.stats[i - 1]; var intervalInSec = getInterval(cur.timestamp, prev.timestamp) / 1000000000; var elements = []; elements.push(cur.timestamp); elements.push( (cur.network.interfaces[interfaceIndex].tx_bytes - prev.network.interfaces[interfaceIndex].tx_bytes) / intervalInSec); elements.push( (cur.network.interfaces[interfaceIndex].rx_bytes - prev.network.interfaces[interfaceIndex].rx_bytes) / intervalInSec); data.push(elements); } drawLineChart(titles, data, elementId, 'Bytes per second'); } // Draw the graph for network errors function drawNetworkErrors(elementId, machineInfo, stats) { if (stats.spec.has_network && !hasResource(stats, 'network')) { return; } // Get interface index. var interfaceIndex = -1; if (stats.stats.length > 0) { interfaceIndex = getNetworkInterfaceIndex( window.cadvisor.network.interface, stats.stats[0].network.interfaces); } if (interfaceIndex < 0) { console.log( 'Unable to find interface"', interfaceName, '" in ', stats.stats.network); return; } var titles = ['Time', 'Tx', 'Rx']; var data = []; for (var i = 1; i < stats.stats.length; i++) { var cur = stats.stats[i]; var prev = stats.stats[i - 1]; var intervalInSec = getInterval(cur.timestamp, prev.timestamp) / 1000000000; var elements = []; elements.push(cur.timestamp); elements.push( (cur.network.interfaces[interfaceIndex].tx_errors - prev.network.interfaces[interfaceIndex].tx_errors) / intervalInSec); elements.push( (cur.network.interfaces[interfaceIndex].rx_errors - prev.network.interfaces[interfaceIndex].rx_errors) / intervalInSec); data.push(elements); } drawLineChart(titles, data, elementId, 'Errors per second'); } // Update the filesystem usage values. function drawFileSystemUsage(machineInfo, stats) { var cur = stats.stats[stats.stats.length - 1]; if (!cur.filesystem) { return; } var el = $('
'); for (var i = 0; i < cur.filesystem.length; i++) { var data = cur.filesystem[i]; var totalUsage = Math.floor((data.usage * 100.0) / data.capacity); // Update DOM elements. var els = window.cadvisor.fsUsage.elements[data.device]; els.progressElement.width(totalUsage + '%'); els.textElement.text( humanizeMetric(data.usage) + ' / ' + humanizeMetric(data.capacity) + ' (' + totalUsage + '%)'); } } function drawImages(images) { if (images == null || images.length == 0) { return; } window.charts = {}; var titles = ['Repository', 'Tags', 'ID', 'Virtual Size', 'Creation Time']; var titleTypes = ['string', 'string', 'string', 'number', 'number']; var sortIndex = 0; var data = []; for (var i = 0; i < images.length; i++) { var elements = []; var tags = []; var repos = images[i].repo_tags[0].split(':'); repos.splice(-1, 1); for (var j = 0; j < images[i].repo_tags.length; j++) { var splits = images[i].repo_tags[j].split(':'); if (splits.length > 1) { tags.push(splits[splits.length - 1]); } } elements.push(repos.join(':')); elements.push(tags.join(', ')); elements.push(images[i].id.substr(0, 24)); elements.push( {v: images[i].virtual_size, f: humanizeIEC(images[i].virtual_size)}); var d = new Date(images[i].created * 1000); elements.push({v: images[i].created, f: d.toLocaleString()}); data.push(elements); } drawTable(titles, titleTypes, data, 'docker-images', 30, sortIndex); } function drawProcesses(isRoot, rootDir, processInfo) { if (processInfo.length == 0) { $('#processes-top').text('No processes found'); return; } var titles = [ 'User', 'PID', 'PPID', 'Start Time', 'CPU %', 'MEM %', 'RSS', 'Virtual Size', 'Status', 'Running Time', 'Command' ]; var titleTypes = [ 'string', 'number', 'number', 'string', 'number', 'number', 'number', 'number', 'string', 'string', 'string' ]; var sortIndex = 4; if (isRoot) { titles.push('Container'); titleTypes.push('string'); } var data = []; for (var i = 0; i < processInfo.length; i++) { var elements = []; elements.push(processInfo[i].user); elements.push(processInfo[i].pid); elements.push(processInfo[i].parent_pid); elements.push(processInfo[i].start_time); elements.push({ v: processInfo[i].percent_cpu, f: processInfo[i].percent_cpu.toFixed(2) }); elements.push({ v: processInfo[i].percent_mem, f: processInfo[i].percent_mem.toFixed(2) }); elements.push({v: processInfo[i].rss, f: humanizeIEC(processInfo[i].rss)}); elements.push({ v: processInfo[i].virtual_size, f: humanizeIEC(processInfo[i].virtual_size) }); elements.push(processInfo[i].status); elements.push(processInfo[i].running_time); elements.push(processInfo[i].cmd); if (isRoot) { var cgroup = processInfo[i].cgroup_path; // Use the raw cgroup link as it works for all containers. var cgroupLink = '' + cgroup.substr(0, 30) + ' '; elements.push({v: cgroup, f: cgroupLink}); } data.push(elements); } drawTable(titles, titleTypes, data, 'processes-top', 25, sortIndex); } // Draw the filesystem usage nodes. function startFileSystemUsage(elementId, machineInfo, stats) { window.cadvisor.fsUsage = {}; // A map of device name to DOM elements. window.cadvisor.fsUsage.elements = {}; var cur = stats.stats[stats.stats.length - 1]; var el = $('
'); if (!cur.filesystem) { return; } for (var i = 0; i < cur.filesystem.length; i++) { var data = cur.filesystem[i]; el.append( $('
') .addClass('row col-sm-12') .append($('

').text('FS #' + (i + 1) + ': ' + data.device))); var progressElement = $('
').addClass('progress-bar progress-bar-danger'); el.append( $('
') .addClass('col-sm-9') .append($('
').addClass('progress').append(progressElement))); var textElement = $('
').addClass('col-sm-3'); el.append(textElement); window.cadvisor.fsUsage.elements[data.device] = { 'progressElement': progressElement, 'textElement': textElement, 'index': i, }; } $('#' + elementId).empty().append(el); drawFileSystemUsage(machineInfo, stats); } // 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, subcontainers) { var steps = []; if (containerInfo.spec.has_cpu || containerInfo.spec.has_memory) { steps.push(function() { drawOverallUsage('usage-gauge', machineInfo, containerInfo); }); } // CPU. if (containerInfo.spec.has_cpu) { steps.push(function() { drawCpuTotalUsage('cpu-total-usage-chart', machineInfo, containerInfo); }); // TODO(rjnagal): Re-enable CPU Load after understanding resource usage. // steps.push(function() { // drawCpuLoad("cpu-load-chart", machineInfo, containerInfo); // }); steps.push(function() { drawCpuPerCoreUsage( 'cpu-per-core-usage-chart', machineInfo, containerInfo); }); steps.push(function() { drawCpuUsageBreakdown( 'cpu-usage-breakdown-chart', machineInfo, containerInfo); }); } // Memory. if (containerInfo.spec.has_memory) { steps.push(function() { drawMemoryUsage('memory-usage-chart', machineInfo, containerInfo); }); } // Network. if (containerInfo.spec.has_network) { steps.push(function() { drawNetworkBytes('network-bytes-chart', machineInfo, containerInfo); }); steps.push(function() { drawNetworkErrors('network-errors-chart', machineInfo, containerInfo); }); } // Filesystem. if (containerInfo.spec.has_filesystem) { steps.push(function() { drawFileSystemUsage(machineInfo, containerInfo); }); } // Custom Metrics if (containerInfo.spec.has_custom_metrics) { steps.push(function() { getCustomMetrics( window.cadvisor.rootDir, window.cadvisor.containerName, function(metricsInfo) { drawCustomMetrics( 'custom-metrics-chart', containerInfo, metricsInfo); }); }); } // Subcontainers. var subcontainerInfos = filterSubcontainers(containerInfo, subcontainers); if (subcontainerInfos.length > 0) { if (hasResourceForAll(subcontainerInfos, 'cpu')) { steps.push(function() { var displayCount = $('#cpu-per-subcontainer-display-count').val(); drawCpuPerSubcontainerUsage( 'cpu-per-subcontainer-usage-chart', sliceByCpu(subcontainerInfos, displayCount)); }); } if (hasResourceForAll(subcontainerInfos, 'memory')) { steps.push(function() { var displayCount = $('#memory-per-subcontainer-display-count').val(); drawMemoryPerSubcontainerUsage( 'memory-per-subcontainer-usage-chart', sliceByMemory(subcontainerInfos, displayCount)); }); } } stepExecute(steps); } // Return an slice of subcontainers sorted by CPU, with at most 'count' entries. function sliceByCpu(subcontainerInfos, count) { subcontainerInfos.sort(function(a, b) { if (a.averages.cpu > b.averages.cpu) { return -1; } else if (a.averages.cpu < b.averages.cpu) { return 1; } else { return compareByName(a, b); } }); return subcontainerInfos.slice(0, Math.min(subcontainerInfos.length, count)) .sort(compareByName); } // Return an slice of subcontainers sorted by memory, with at most 'count' // entries. function sliceByMemory(subcontainerInfos, count) { subcontainerInfos.sort(function(a, b) { if (a.averages.memory > b.averages.memory) { return -1; } else if (a.averages.memory < b.averages.memory) { return 1; } else { return compareByName(a, b); } }); return subcontainerInfos.slice(0, Math.min(subcontainerInfos.length, count)) .sort(compareByName); } // Return sort comparitor based on subcontroller name. function compareByName(subA, subB) { if (subA.name > subB.name) { return 1; } else if (subA.name < subB.name) { return -1; } else { return 0; } } // Return a map of the averages of the subcontainer stats. function getSubcontainerAverages(subcontainer) { var cpuSum = 0; var memorySum = 0; subcontainer.stats.forEach(function(stat) { cpuSum += stat.cpu.usage.total; memorySum += stat.memory.usage / oneMegabyte; }); return { cpu: cpuSum / subcontainer.stats.length, memory: memorySum / subcontainer.stats.length, } } // Return a list of immediate subcontainers, including metric averages. function filterSubcontainers(containerInfo, subcontainers) { if (!containerInfo.subcontainers || containerInfo.subcontainers.length === 0 || !subcontainers) { return []; } var subcontainerNames = {}; containerInfo.subcontainers.forEach(function(subcontainer) { subcontainerNames[subcontainer.name] = subcontainer.name; }); var subcontainerInfos = []; subcontainers.forEach(function(subcontainer) { if (subcontainerNames[subcontainer.name] !== undefined) { subcontainer.averages = getSubcontainerAverages(subcontainer); subcontainerInfos.push(subcontainer); } }); return subcontainerInfos; } function setNetwork(interfaceName) { $('#network-selection-text') .empty() .append($('').text('Interface: ')) .append($('').text(interfaceName)); window.cadvisor.network.interface = interfaceName; // Draw the new stats. refreshStats(); } // Creates the network selection dropdown. function startNetwork(selectionElement, containerInfo) { if (!hasResource(containerInfo, 'network') || containerInfo.stats.length == 0 || !containerInfo.stats[0].network.interfaces || containerInfo.stats[0].network.interfaces.length == 0) { return; } window.cadvisor.network = {}; window.cadvisor.network.interface = ''; // Add all interfaces to the dropdown. var el = $('#' + selectionElement); for (var i = 0; i < containerInfo.stats[0].network.interfaces.length; i++) { var interfaceName = containerInfo.stats[0].network.interfaces[i].name; el.append($('
  • ') .attr('role', 'presentation') .append($('') .attr('role', 'menuitem') .attr('tabindex', -1) .click(setNetwork.bind(null, interfaceName)) .text(interfaceName))); } setNetwork(containerInfo.stats[0].network.interfaces[0].name); } // Refresh the stats on the page. function refreshStats() { var machineInfo = window.cadvisor.machineInfo; getStats( window.cadvisor.rootDir, window.cadvisor.containerName, function(containerInfo, subcontainers) { if (window.cadvisor.firstRun) { window.cadvisor.firstRun = false; if (containerInfo.spec.has_filesystem) { startFileSystemUsage( 'filesystem-usage', machineInfo, containerInfo); } if (containerInfo.spec.has_network) { startNetwork('network-selection', containerInfo); } if (containerInfo.spec.has_custom_metrics) { startCustomMetrics('custom-metrics-chart', containerInfo); } } drawCharts(machineInfo, containerInfo, subcontainers); }); } function addAllLabels(containerInfo, metricsInfo) { if (metricsInfo.length == 0) { return; } var metricSpec = containerInfo.spec.custom_metrics; for (var containerName in metricsInfo) { var container = metricsInfo[containerName]; for (i = 0; i < metricSpec.length; i++) { metricName = metricSpec[i].name; metricLabelVal = container[metricName]; firstLabel = true; for (var label in metricLabelVal) { if (label == '') { $('#button-' + metricName).hide(); } $('#' + metricName + '_labels') .append( $('
  • ') .attr('role', 'presentation') .append($('') .attr('role', 'menuitem') .click(setLabel.bind(null, metricName, label)) .text(label))); if (firstLabel) { firstLabel = false; setLabel(metricName, label); } } } } } function getMetricIndex(metricName) { for (i = 0; i < window.cadvisor.metricLabelPair.length; ++i) { if (window.cadvisor.metricLabelPair[i][0] == metricName) { return i; } } return -1; } function setLabel(metric, label) { $('#' + metric + '-selection-text') .empty() .append($('').text('Label: ')) .append($('').text(label)); index = getMetricIndex(metric); if (index == -1) { window.cadvisor.metricLabelPair.push([metric, label]); } else { window.cadvisor.metricLabelPair[index][1] = label; } refreshStats(); } function getSelectedLabel(metricName) { index = getMetricIndex(metricName); if (index == -1) { return ''; } return window.cadvisor.metricLabelPair[index][1]; } function startCustomMetrics(elementId, containerInfo) { var metricSpec = containerInfo.spec.custom_metrics; var metricStats = containerInfo.stats.custom_metrics; var el = $('
    '); if (metricSpec.length < window.cadvisor.maxCustomMetrics) { window.cadvisor.maxCustomMetrics = metricSpec.length; for (i = 0; i < window.cadvisor.maxCustomMetrics; i++) { metricName = metricSpec[i].name; var divText = '
    '; divText += '
    '; divText += '
    '; el.append($(divText)); } } el.append($('
    ')); $('#' + elementId).append(el); } function getCustomMetrics(rootDir, containerName, callback) { $.getJSON(rootDir + 'api/v2.0/appmetrics/' + containerName) .done(function(data) { callback(data); }) .fail(function(jqhxr, textStatus, error) { callback([]); }); } function drawCustomMetrics(elementId, containerInfo, metricsInfo) { if (metricsInfo.length == 0) { return; } var metricSpec = containerInfo.spec.custom_metrics; for (var containerName in metricsInfo) { var container = metricsInfo[containerName]; for (i = 0; i < window.cadvisor.maxCustomMetrics; i++) { metricName = metricSpec[i].name; metricUnits = metricSpec[i].units; var titles = ['Time', metricName]; metricLabelVal = container[metricName]; if (window.cadvisor.firstCustomCollection) { window.cadvisor.firstCustomCollection = false; addAllLabels(containerInfo, metricsInfo); } var data = []; selectedLabel = getSelectedLabel(metricName); metricVal = metricLabelVal[selectedLabel]; for (var index in metricVal) { metric = metricVal[index]; var elements = []; for (var attribute in metric) { value = metric[attribute]; elements.push(value); } if (elements.length < 2) { elements.push(0); } data.push(elements); } drawLineChart(titles, data, elementId + '-' + metricName, metricUnits); } } } // Executed when the page finishes loading. function startPage(containerName, hasCpu, hasMemory, rootDir, isRoot) { // Don't fetch data if we don't have any resource. if (!hasCpu && !hasMemory) { return; } window.charts = {}; window.cadvisor = {}; window.cadvisor.firstRun = true; window.cadvisor.rootDir = rootDir; window.cadvisor.containerName = containerName; window.cadvisor.firstCustomCollection = true; window.cadvisor.metricLabelPair = []; window.cadvisor.maxCustomMetrics = 10; // Draw process information at start and refresh every 60s. getProcessInfo(rootDir, containerName, function(processInfo) { drawProcesses(isRoot, rootDir, processInfo); }); setInterval(function() { getProcessInfo(rootDir, containerName, function(processInfo) { drawProcesses(isRoot, rootDir, processInfo); }); }, 60000); // Get machine info, then get the stats every 1s. getMachineInfo(rootDir, function(machineInfo) { window.cadvisor.machineInfo = machineInfo; setInterval(function() { refreshStats(); }, 1000); }); } cadvisor-0.25.0/pages/assets/styles/000077500000000000000000000000001306035727200173415ustar00rootroot00000000000000cadvisor-0.25.0/pages/assets/styles/containers.css000066400000000000000000004033511306035727200222260ustar00rootroot00000000000000 .google-visualization-toolbar{font-size:100%}.google-visualization-toolbar .google-visualization-toolbar-export-igoogle,.google-visualization-toolbar .google-visualization-toolbar-export-data,.google-visualization-toolbar .google-visualization-toolbar-html-code{margin-right:.1em}.google-visualization-toolbar-html-code-explanation{font-weight:bold}.google-visualization-toolbar-ok-button{padding:2px}.google-visualization-toolbar-triangle{position:absolute;right:0;top:0}.google-visualization-toolbar-caption-table{width:100%;padding:0;margin:0;border:0;border-collapse:collapse}.google-visualization-toolbar-small-dialog{width:500px}.google-visualization-toolbar-big-dialog{width:800px}.google-visualization-toolbar-small-dialog,.google-visualization-toolbar-big-dialog{position:absolute;background-color:#c1d9ff;border:1px solid #3a5774;padding:8px}.google-visualization-toolbar-small-dialog-bg,.google-visualization-toolbar-big-dialog-bg{background-color:#ddd;position:absolute;top:0;left:0}.google-visualization-toolbar-small-dialog-title,.google-visualization-toolbar-big-dialog-title{background-color:#e0edfe;color:#000;cursor:pointer;padding:8px;position:relative;font-size:12pt;font-weight:bold;vertical-align:middle}.google-visualization-toolbar-small-dialog-content,.google-visualization-toolbar-big-dialog-content{background-color:#fff;padding:4px;font-weight:normal;overflow:auto}.google-visualization-toolbar-small-dialog-title-close,.google-visualization-toolbar-big-dialog-title-close{background:transparent url(close_box.gif) no-repeat scroll center;height:15px;position:absolute;right:10px;top:8px;width:15px}.google-visualization-toolbar-small-dialog-content iframe,.google-visualization-toolbar-big-dialog-content iframe{width:500px;height:700px;border:1px solid black}.charts-inline-block{position:relative;display:-moz-inline-box;display:inline-block}* html .charts-inline-block,*:first-child+html .charts-inline-block{display:inline}.charts-menu{background:#fff;border-color:#ccc #666 #666 #ccc;border-style:solid;border-width:1px;cursor:default;font:normal 13px Arial,sans-serif;margin:0;outline:none;padding:4px 0;position:absolute;z-index:20000}.charts-menu-button{background:#ddd url(//ssl.gstatic.com/editor/button-bg.png) repeat-x top left;border:0;color:#000;cursor:pointer;list-style:none;margin:2px;outline:none;padding:0;text-decoration:none;vertical-align:middle}.charts-menu-button-outer-box,.charts-menu-button-inner-box{border-style:solid;border-color:#aaa;vertical-align:top}.charts-menu-button-outer-box{margin:0;border-width:1px 0;padding:0}.charts-menu-button-inner-box{margin:0 -1px;border-width:0 1px;padding:3px 4px}* html .charts-menu-button-inner-box{left:-1px}* html .charts-menu-button-rtl .charts-menu-button-outer-box{left:-1px;right:auto}* html .charts-menu-button-rtl .charts-menu-button-inner-box{right:auto}*:first-child+html .charts-menu-button-inner-box{left:-1px}*:first-child+html .charts-menu-button-rtl .charts-menu-button-inner-box{left:1px;right:auto}::root .charts-menu-button{line-height:0}::root .charts-menu-button-outer-box{line-height:0}::root .charts-menu-button-inner-box{line-height:0}::root .charts-menu-button-caption{line-height:normal}::root .charts-menu-button-dropdown{line-height:normal}.charts-menu-button-disabled{background-image:none!important;opacity:.3;-moz-opacity:.3;filter:alpha(opacity=30)}.charts-menu-button-disabled .charts-menu-button-outer-box,.charts-menu-button-disabled .charts-menu-button-inner-box,.charts-menu-button-disabled .charts-menu-button-caption,.charts-menu-button-disabled .charts-menu-button-dropdown{color:#333!important;border-color:#999!important}* html .charts-menu-button-disabled,*:first-child+html .charts-menu-button-disabled{margin:2px 1px!important;padding:0 1px!important}.charts-menu-button-hover .charts-menu-button-outer-box,.charts-menu-button-hover .charts-menu-button-inner-box{border-color:#9cf #69e #69e #7af!important}.charts-menu-button-active,.charts-menu-button-open{background-color:#bbb;background-position:bottom left}.charts-menu-button-focused .charts-menu-button-outer-box,.charts-menu-button-focused .charts-menu-button-inner-box{border-color:orange}.charts-menu-button-caption{padding:0 4px 0 0;vertical-align:top}.charts-menu-button-dropdown{height:15px;width:7px;background:url(//ssl.gstatic.com/editor/editortoolbar.png) no-repeat -388px 0;vertical-align:top}.charts-menu-button-collapse-right,.charts-menu-button-collapse-right .charts-menu-button-outer-box,.charts-menu-button-collapse-right .charts-menu-button-inner-box{margin-right:0}.charts-menu-button-collapse-left,.charts-menu-button-collapse-left .charts-menu-button-outer-box{margin-left:0}.charts-menu-button-collapse-left .charts-menu-button-inner-box{margin-left:0;border-left:1px solid #fff}.charts-menu-button-collapse-left.charts-menu-button-checked .charts-menu-button-inner-box{border-left:1px solid #ddd}.charts-menuitem{color:#000;font:normal 13px Arial,sans-serif;list-style:none;margin:0;padding:4px 7em 4px 28px;white-space:nowrap}.charts-menuitem.charts-menuitem-rtl{padding-left:7em;padding-right:28px}.charts-menu-nocheckbox .charts-menuitem,.charts-menu-noicon .charts-menuitem{padding-left:12px}.charts-menu-noaccel .charts-menuitem{padding-right:20px}.charts-menuitem-content{color:#000;font:normal 13px Arial,sans-serif}.charts-menuitem-disabled .charts-menuitem-accel,.charts-menuitem-disabled .charts-menuitem-content{color:#ccc!important}.charts-menuitem-disabled .charts-menuitem-icon{opacity:.3;-moz-opacity:.3;filter:alpha(opacity=30)}.charts-menuitem-highlight,.charts-menuitem-hover{background-color:#d6e9f8;border-color:#d6e9f8;border-style:dotted;border-width:1px 0;padding-bottom:3px;padding-top:3px}.charts-menuitem-checkbox,.charts-menuitem-icon{background-repeat:no-repeat;height:16px;left:6px;position:absolute;right:auto;vertical-align:middle;width:16px}.charts-menuitem-rtl .charts-menuitem-checkbox,.charts-menuitem-rtl .charts-menuitem-icon{left:auto;right:6px}.charts-option-selected .charts-menuitem-checkbox,.charts-option-selected .charts-menuitem-icon{background:url(//ssl.gstatic.com/editor/editortoolbar.png) no-repeat -512px 0}.charts-menuitem-accel{color:#999;direction:ltr;left:auto;padding:0 6px;position:absolute;right:0;text-align:right}.charts-menuitem-rtl .charts-menuitem-accel{left:0;right:auto;text-align:left}.charts-menuitem-mnemonic-hint{text-decoration:underline}.charts-menuitem-mnemonic-separator{color:#999;font-size:12px;padding-left:4px} .stat-label { font-weight:bold; } .unit-label { color:#888888; font-style:italic; } .active-cpu { font-weight:bold; color:#000000; } .inactive-cpu { color:#888888; } .raw-stats { font-family: "Courier New"; white-space: pre-wrap; } .isolation-title { color:#FFFFFF; } .page-header h1 { word-wrap: break-word; } .table-row { font-family: "courier", "monospace"; font-size: 15px; text-align: right; vertical-align: top; border: 5px; margin-left: 3px; margin-right: 3px; margin-top: 3px; margin-bottom: 3px; } .subcontainer-display-input { margin-left: 4px; width: 40px; } #logo { height: 200px; margin-top: 20px; background-repeat: no-repeat; background-size: contain; background-position: center; background-image:url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAB7UAAANiCAIAAACB2Qp3AAAKSWlDQ1BzUkdCIElFQzYxOTY2LTIuMQAAeNqdU3dYk/cWPt/3ZQ9WQtjwsZdsgQAiI6wIyBBZohCSAGGEEBJAxYWIClYUFRGcSFXEgtUKSJ2I4qAouGdBiohai1VcOO4f3Ke1fXrv7e371/u855zn/M55zw+AERImkeaiagA5UoU8Otgfj09IxMm9gAIVSOAEIBDmy8JnBcUAAPADeXh+dLA//AGvbwACAHDVLiQSx+H/g7pQJlcAIJEA4CIS5wsBkFIAyC5UyBQAyBgAsFOzZAoAlAAAbHl8QiIAqg0A7PRJPgUA2KmT3BcA2KIcqQgAjQEAmShHJAJAuwBgVYFSLALAwgCgrEAiLgTArgGAWbYyRwKAvQUAdo5YkA9AYACAmUIszAAgOAIAQx4TzQMgTAOgMNK/4KlfcIW4SAEAwMuVzZdL0jMUuJXQGnfy8ODiIeLCbLFCYRcpEGYJ5CKcl5sjE0jnA0zODAAAGvnRwf44P5Dn5uTh5mbnbO/0xaL+a/BvIj4h8d/+vIwCBAAQTs/v2l/l5dYDcMcBsHW/a6lbANpWAGjf+V0z2wmgWgrQevmLeTj8QB6eoVDIPB0cCgsL7SViob0w44s+/zPhb+CLfvb8QB7+23rwAHGaQJmtwKOD/XFhbnauUo7nywRCMW735yP+x4V//Y4p0eI0sVwsFYrxWIm4UCJNx3m5UpFEIcmV4hLpfzLxH5b9CZN3DQCshk/ATrYHtctswH7uAQKLDljSdgBAfvMtjBoLkQAQZzQyefcAAJO/+Y9AKwEAzZek4wAAvOgYXKiUF0zGCAAARKCBKrBBBwzBFKzADpzBHbzAFwJhBkRADCTAPBBCBuSAHAqhGJZBGVTAOtgEtbADGqARmuEQtMExOA3n4BJcgetwFwZgGJ7CGLyGCQRByAgTYSE6iBFijtgizggXmY4EImFINJKApCDpiBRRIsXIcqQCqUJqkV1II/ItchQ5jVxA+pDbyCAyivyKvEcxlIGyUQPUAnVAuagfGorGoHPRdDQPXYCWomvRGrQePYC2oqfRS+h1dAB9io5jgNExDmaM2WFcjIdFYIlYGibHFmPlWDVWjzVjHVg3dhUbwJ5h7wgkAouAE+wIXoQQwmyCkJBHWExYQ6gl7CO0EroIVwmDhDHCJyKTqE+0JXoS+cR4YjqxkFhGrCbuIR4hniVeJw4TX5NIJA7JkuROCiElkDJJC0lrSNtILaRTpD7SEGmcTCbrkG3J3uQIsoCsIJeRt5APkE+S+8nD5LcUOsWI4kwJoiRSpJQSSjVlP+UEpZ8yQpmgqlHNqZ7UCKqIOp9aSW2gdlAvU4epEzR1miXNmxZDy6Qto9XQmmlnafdoL+l0ugndgx5Fl9CX0mvoB+nn6YP0dwwNhg2Dx0hiKBlrGXsZpxi3GS+ZTKYF05eZyFQw1zIbmWeYD5hvVVgq9ip8FZHKEpU6lVaVfpXnqlRVc1U/1XmqC1SrVQ+rXlZ9pkZVs1DjqQnUFqvVqR1Vu6k2rs5Sd1KPUM9RX6O+X/2C+mMNsoaFRqCGSKNUY7fGGY0hFsYyZfFYQtZyVgPrLGuYTWJbsvnsTHYF+xt2L3tMU0NzqmasZpFmneZxzQEOxrHg8DnZnErOIc4NznstAy0/LbHWaq1mrX6tN9p62r7aYu1y7Rbt69rvdXCdQJ0snfU6bTr3dQm6NrpRuoW623XP6j7TY+t56Qn1yvUO6d3RR/Vt9KP1F+rv1u/RHzcwNAg2kBlsMThj8MyQY+hrmGm40fCE4agRy2i6kcRoo9FJoye4Ju6HZ+M1eBc+ZqxvHGKsNN5l3Gs8YWJpMtukxKTF5L4pzZRrmma60bTTdMzMyCzcrNisyeyOOdWca55hvtm82/yNhaVFnMVKizaLx5balnzLBZZNlvesmFY+VnlW9VbXrEnWXOss623WV2xQG1ebDJs6m8u2qK2brcR2m23fFOIUjynSKfVTbtox7PzsCuya7AbtOfZh9iX2bfbPHcwcEh3WO3Q7fHJ0dcx2bHC866ThNMOpxKnD6VdnG2ehc53zNRemS5DLEpd2lxdTbaeKp26fesuV5RruutK10/Wjm7ub3K3ZbdTdzD3Ffav7TS6bG8ldwz3vQfTw91jicczjnaebp8LzkOcvXnZeWV77vR5Ps5wmntYwbcjbxFvgvct7YDo+PWX6zukDPsY+Ap96n4e+pr4i3z2+I37Wfpl+B/ye+zv6y/2P+L/hefIW8U4FYAHBAeUBvYEagbMDawMfBJkEpQc1BY0FuwYvDD4VQgwJDVkfcpNvwBfyG/ljM9xnLJrRFcoInRVaG/owzCZMHtYRjobPCN8Qfm+m+UzpzLYIiOBHbIi4H2kZmRf5fRQpKjKqLupRtFN0cXT3LNas5Fn7Z72O8Y+pjLk722q2cnZnrGpsUmxj7Ju4gLiquIF4h/hF8ZcSdBMkCe2J5MTYxD2J43MC52yaM5zkmlSWdGOu5dyiuRfm6c7Lnnc8WTVZkHw4hZgSl7I/5YMgQlAvGE/lp25NHRPyhJuFT0W+oo2iUbG3uEo8kuadVpX2ON07fUP6aIZPRnXGMwlPUit5kRmSuSPzTVZE1t6sz9lx2S05lJyUnKNSDWmWtCvXMLcot09mKyuTDeR55m3KG5OHyvfkI/lz89sVbIVM0aO0Uq5QDhZML6greFsYW3i4SL1IWtQz32b+6vkjC4IWfL2QsFC4sLPYuHhZ8eAiv0W7FiOLUxd3LjFdUrpkeGnw0n3LaMuylv1Q4lhSVfJqedzyjlKD0qWlQyuCVzSVqZTJy26u9Fq5YxVhlWRV72qX1VtWfyoXlV+scKyorviwRrjm4ldOX9V89Xlt2treSrfK7etI66Trbqz3Wb+vSr1qQdXQhvANrRvxjeUbX21K3nShemr1js20zcrNAzVhNe1bzLas2/KhNqP2ep1/XctW/a2rt77ZJtrWv913e/MOgx0VO97vlOy8tSt4V2u9RX31btLugt2PGmIbur/mft24R3dPxZ6Pe6V7B/ZF7+tqdG9s3K+/v7IJbVI2jR5IOnDlm4Bv2pvtmne1cFoqDsJB5cEn36Z8e+NQ6KHOw9zDzd+Zf7f1COtIeSvSOr91rC2jbaA9ob3v6IyjnR1eHUe+t/9+7zHjY3XHNY9XnqCdKD3x+eSCk+OnZKeenU4/PdSZ3Hn3TPyZa11RXb1nQ8+ePxd07ky3X/fJ897nj13wvHD0Ivdi2yW3S609rj1HfnD94UivW2/rZffL7Vc8rnT0Tes70e/Tf/pqwNVz1/jXLl2feb3vxuwbt24m3Ry4Jbr1+Hb27Rd3Cu5M3F16j3iv/L7a/eoH+g/qf7T+sWXAbeD4YMBgz8NZD+8OCYee/pT/04fh0kfMR9UjRiONj50fHxsNGr3yZM6T4aeypxPPyn5W/3nrc6vn3/3i+0vPWPzY8Av5i8+/rnmp83Lvq6mvOscjxx+8znk98ab8rc7bfe+477rfx70fmSj8QP5Q89H6Y8en0E/3Pud8/vwv94Tz+0/JIZ8AAAAGYktHRAD/AP8A/6C9p5MAAAAJcEhZcwAALiMAAC4jAXilP3YAAAAHdElNRQfeBgQSIjPjAuUgAAAgAElEQVR42uzdd2Bb13n3cWIRIEESJLj3piRObYlatiXZluQtecojsZ2kWc2O0yZt47Rv03RkOsmbpmlG471lW8Na1rAmh0RKHCIl7j0BkgBBjIv3D6V+HQ9FIoF7D4Dv5w+3kSmc5z7n8ML84fBcldfrDQMAAAAAICg4HA6DwUAfAIQsu90eGRlJH4CrpKYFAAAAAICgUV1T+8abb1knJmgFgFDT09P7h/95urOrm1YAV0/F/nEAAAAAQNCYmZn5jx/9xOVyLV2yeN26tTHR0fQEQNDr6e09ePBQS2trSkryFz//ORoCXD3ycQAAAABAUNl/4OChw0fCwsK0Wu3yZUvXrV0TFRVFWwAEpf7+/gMHD11oabkc8d137z1lpSW0Bbh65OMAAAAAgKBit9v//Yc/drlcl/+nTqe7nJIbjUaaAyBoDAwMHnznUFNz83vhnjku7qtf+ZJKpaI5wNUjHwcAAAAABJs339p56nTV+//kckq+ds1q9pIDCHQDAwMH3zn8/mT8sttuvWXF8mX0B7gm5OMAAAAAgGAzNj7+k58+JUnSB/6clBxAQPu4ZDwsLCwyMvKJb3xNq9XSJeCakI8DAAAAAILQM88+19R84SP/FSk5gIBzhWT8suvWrb1x4wYaBVwr8nEAAAAAQBBqa2v/7e//cIUv0Ol0y5YuWbtmdXR0NO0CIKz+/oF3Dl0pGQ8LC9NoNF//6pdjYmJoF3Ct+J0LAAAAAEAQysvLTU5OGhwc+rgvcLlcx0+crKquWbJ40dq1a0zkSgAE09vb986hwxdaWv7i9tbi4gWE48DssH8cAAAAABCcTp2uevOtnVfzlVqtdvGihWvXromLjaVvABTX1dX9zqHDrRcvXuXXf+qxR3NysukbMAvk4wAAAACA4OR0Ov/13384MzNzlV+v0WgqKsqvX7fWbDbTPQCKaG/vOHT4yKW2tqv/K0lJSV/64udpHTA7nK8CAAAAAAhO4eHhFeVlp6uqr/LrPR5Pbe2Zs2frysvLrr9uXUJ8PD0EIJtLl9reOXy4o6PzWv/i8mVL6R4wa+TjAAAAAICgtWTx4qvPxy+TJOns2br6+nPFCxZct25tamoKbQTgV03NF44cOdrd0zOLv6vVahdWlNNDYNbIxwEAAAAAQSs9PS05OXlwcPBa/6IkSecbGhoaG4sKC6+7bm1WZibNBOBbXq/33PmGw0eOzuIe9Z7iBfMNBgPNBGaNfBwAAAAAEMwWL1q4e8/bs/u7Xq/3QkvLhZaW3Jyc69atLSjIp58A5k6SpDNn644efXdkdHTOt7hF9BOYC/JxAAAAAEAwW1hRvnfffo/HM5cXae/oaO/oSE9Pu27duuIF8+kqgNlxu93VNbXvvnvMYrXO/dVMJlN+fh5dBeaCfBwAAAAAEMyMRmNRYWFTc/PcX6q3t+/Z555PSkpau2Z1RXmZWq2mvQCuksPhOHW66sTJU1NTU756zUULK1QqFb0F5kLl9XrpAgAAAAAgiDU1X3jm2ed8+5qxJtPq1auWLlms0+noMIArmJycPH7i5Omq6pmZGR++rEql+uqX/9psNtNhYC7YPw4AAAAACHLzigqNRqPNZvPha1qs1p27dr9z6PCK5csqV66IjIykzwA+YGRk5Mi7x+rrz7ndbp+/eFZmJuE4MHfsHwcAAAAABL833nzrdFW1n148PDx8yeJFq1evijWZaDWAsLCw7p6eo0ePNV+4IEmSn4a49ZYtK1csp9XAHLF/HAAAAAAQ/MpKS/2XjzudzhMnT52uqi4tLVmzalVqagoNB0JW84WWY8eOt3d0+HUUtVpdWlJMt4G5Ix8HAAAAAAS/nJzs6OjoyclJ/w3h8Xjq6urr6urz8/LWrF5VWFhA24HQ4Xa7z9bVHzt2fHhkRJ57WlRUFG0H5o58HAAAAAAQ/FQqVWlJ8YmTp2QY61Jb26W2tqSkpDWrV1WUl2k0GvoPBDG73X7y1OlTp6t8+5CDKysrLaXzgG/+C4HzxwEAAAAAoaCru/vX//XfMg8aFRW1csXyFcuXRUREMAVAkBkZHT1+/MSZs3Uul0vOcTUazd888Q3uKoBPsH8cAAAAABASsjIzY00mi9Uq56BTU1P7Dxw8cvTdRQsrKleuSEhIYCKAINDW1n78xMmW1lb/PX7zCvLycgnHAV8hHwcAAAAAhIqSkuJjx0/IP67T6Tx1uup0VXVhQcGqypUFBfnMBRCI3G53Xf254ydODg4OKlhGaUkJcwH4Cvk4AAAAACBUzJ8/T5F8/DKv19vS2trS2pqYkLBy5YrFixbqdDomBQgIE5OTp06drqqusdvtylaiVqvnzytiRgBfIR8HAAAAAISK7KysiIiI6elpZcsYHhl5862d+w8cXLpk8YoVy2NNJqYGEFZPT+/xkycbGho9Ho8I9WSkpxuNRuYF8BXycQAAAABAqFCr1UVFhXV19SIUMz09ffTdY8eOn5g/r2jF8uX5+XlMECAOt9t97nzD6dNV3T09QhU2f/48ZgfwIfJxAAAAAEAImT9vniD5+GWSJDU2NTc2NSfExy9btnTxooU8dg9Q1tj4eFVVdU3tGcWPUvm4mxhzBPgQ+TgAAAAAIIQUFRZoNBpBzkl4v5HR0d173t5/4GBZWemKZcvS09OYLEBOXq+3+UJLVVX1xUuXJEkSs0hzXFxSUiKTBfgQ+TgAAAAAIITo9fqcnOxLl9rELM/lctXWnqmtPZOenrZ82bLyslKe4Qn4m81mq66praqusVgsgpfK4SqAz6m8Xi9dAAAAAACEjhMnT+3ctTsgSjUYDOVlpUsWL2Y7OeBzXq/3QktrTU1tS2urgL9T8pEe/eQj+Xk8qwDwJfaPAwAAAABCS0HgPAnT4XCcrqo+XVWdmpqyZPHihRXlBoOBGQTmaHx8vKb2TO2ZsxMTEwFUtk6ny87KYvoA3yIfBwAAAACElsTExOjo6MnJyQCqub9/4K2du97eu6+4eMHSxYtzc3OYR+BaeTyehsammpratvb2QDxQITsrS6slygN8jG8qAAAAAEDIKcjPO3O2LuDKdrlcdXX1dXX18fHxixZWVJSXxcXFMZvy83q9nv/l9Xq9Xq9Hkrz/S/U+6sv/VKs1Gs3lf6pUKhoov+7unrN1dfXnzk9PTwfwjasgn6kEfI7zxwEAAAAAIedsXf3Lr7wa8D/Sq1RZmZkVFeVlpSURERFM69Xzer3T09P26WnHtMPhuPwPh8PhmJmZcTqdM06n0+l0zjhnnDNul9vpcrlcLrfb7Xa7XS7X5Ux81kNfTsm1Wq1Wq9VdptXqdLrw8PBw/Z/+odfrDf8r4k//Vx8ZGcnpOtdqbGzsbF392br6sbGxILicL3zus6mpKUwr4FvsHwcAAAAAhJyC/DyVKuB3jHm93s6urs6urp27dhcVFlZUlM+fV8TxC2FhYS6Xa2Jycmpyaspmm5qampqampyask1N2e3TNrvdbrc7HA5JkhSpTZIkSZJcLtcs/q5arY68LCIiMjIiOjo6KirKaDQajcboqKjomOiY6GiNRsMCmJ6ePne+4ezZuq7u7qC5KKPRSDgO+APvmgAAAACAkBMVFZWUlDg4OBQcl+PxeJqam5uamw0GQ3HxgrKSkvz8PLVaHdyT6Ha7LVarZdxisVqtVqvFYpmcnJqYnJyYmHA4HEF5yZIkXY77r/A1kZGRMTExppiYmJjo2NhYk8kUazLFxsWaYmKC/miXmZmZxqbm8+cbLrW1ud3uILu6vLxcbt2AP5CPAwAAAABCUX5eXtDk4+9xOBy1tWdqa89ERkYuWDC/tKQ4Lzc3CDYUT01NjYyOjo2Nj4+Pj42Pj4+Nj42P22w2zoz9MLvdbrfbBwYGPvDnarU6JibGHBcXZ44zx8XFxcWZzXHxZnMQnMwzPT3d3HzhfENjUMbi7ynIy2N5A/7A+eMAAAAAgFDU2NT07HMvBP1lGgyGoqLC4vnzCwsL9Hq9+AW73e7h4ZGh4eHR0dGR0dGRkdHR0dGZmRlWrJ9ERkYmxMfHJ8QnxMcnJCQkJSXGm80B8csHVqu1qflCY2NTZ1eXx+MJ+pn66pf/Oj4+nhUL+Bz7xwEAAAAAoSgnOzsIjiD/ixwOR339ufr6cxqNJic7e968onlFheKkbB6PZ2hoeHBoaHBw8HIsbrFYlDoZPDTZ7fYuu/3953RrNJr4+PikxMTExITk5OSUlOR4s1mQs1m8Xm9PT++FlpbmCy0f3iMfxKKiogjHAT9h/zgAAAAAIET99KlfDA8Ph+CFx8XFFRbk5+fn5+flGgwGOYe22Wz9/QN9/f39AwODg0Ojo6OhsPM30Ol0uuSkpOSU5JTk5LTU1NTUlPDwcDkLsFgsFy+1Xbx46VJb2/T0dAhOQWlJ8f333ctSBPyBfBwAAAAAEKJe3/FGdU1tKHdArVYnJyfn5mRnZ2fnZGcZjUafDzE1NdXT29fb23s5Fp+YmGDhBcGyMZvNaWmpaamp6WlpaWmp/ji6Z2xsrKOzq6Ozs729Y3x8PMR7vmXzplWVK1l7gD+QjwMAAAAAQlRN7ZnXXt9BH94TFxeXmZmRkZ6elpqakpI8u63lLpert7evp7e3p6e3p7fXYrHQ2OCmUqni4+MzMtIz0tMz0tPT0lJnd3y5xWrt7x8YGBi4vHJsNhu9fc9nP/PpjIx0+gD4A+ePAwAAAABCVFZmBk14v/Hx8fHx8fr6c5f/p8lkSkpMjI83m81mk8kUHRUVHRNtjIzU6XTvnUbt9Xrtdvvk5OTg0HB3d3dnV/fQ0BBHpoQUr9c7MjIyMjJy9mxdWFiYTqdLT0vLzMzIzMxMSkqMMhrf/0GLJEkzMzM2u31qcmpycnLcYhkZHR0dGR0aHg7Ng1OuhlarTU1NoQ+Av77FaAEAAAAAIDQlJiYaDAaHw0ErPpLVarVara0XP+JfXY7IJUnyeDz8Yjrez+VydXR2dnR2vvcn6v8lSZLb7aZF1yotLVWj0dAHwE/UtAAAAAAAELLS09Jowiy4XC6n0+l2uwnH8RddjsUvLxi6wW0KEA35OAAAAAAgdKWlpdIEACIjHwf8inwcAAAAABC6CJ4ACC6N2xTgT+TjAAAAAIDQlcr+cQAC0+l0iYkJ9AHwH/JxAAAAAEDoijebw8PD6QMAMSUnJalUKvoA+A/5OAAAAAAgpCUnJ9EEAILeoFKSaQLgV+TjAAAAAICQlpxM/ARAUCncoAA/Ix8HAAAAAIS05CT2jwMQVFJSIk0A/Ip8HAAAAAAQ0hITePYdAG5QQIgiHwcAAAAAhLSEROInACLS6/UxMTH0AfAr8nEAAAAAQEiLNZl0Oh19ACCahIR4mgD4G/k4AAAAACDUxcXF0QQAojFzawL8j3wcAAAAABDqCKEACIiP7gAZkI8DAAAAAEKd2UwIBUDAW5OZJgD+Rj4OAAAAAAh1JpOJJgAQTSy3JsD/yMcBAAAAAKHOFBNDEwCIJoZbE+B/5OMAAAAAgFAXYyKEAiAcE7cmwP/IxwEAAAAAoS46OpomABCKTqfT6/X0AfA38nEAAAAAQKgzRkbSBABi3ZeMRpoAyIB8HAAAAAAQ6sLDw3U6HX0AIA6jkc/tADmQjwMAAAAAEBYZEUETAAh0U+L3WgBZkI8DAAAAABDGOb8AxLophXNTAuRAPg4AAAAAAPk4AMFuSgZuSoAcyMcBAAAAAAgL14fTBADi0IdzUwLkQD4OAAAAAECYRqOhCQC4KQGhhnwcAAAAAIAwjZooCoBINyXycUAW5OMAAAAAAIRpNPyADEAgajU3JUCW7zVaAAAAAACAJHlpAgBxeL3clAA5kI8DAAAAABAmSRJNACAOj8dDEwAZkI8DAAAAABDmkYiiAAiED+0AeZCPAwAAAAAQ5pxx0gQA4piZmaEJgAzIxwEAAAAACHPMOGgCAJFuSuTjgBzIxwEAAAAACJueJh8HIBAHNyVAFuTjAAAAAIBQ5/V6bTYbfQAgjonJSZoAyIB8HAAAAAAQ6qampjwens8JQCATExM0AZAB+TgAAAAAINRZLFaaAEAo09PTPKITkAH5OAAAAAAg1A0PD9MEAOLdmkZoAuBv5OMAAAAAgFA3RD4OgFsTEJLIxwEAAAAAoa6nt5cmABBNL7cmwP/IxwEAAAAAIU2SpN7ePvoAQDSdXd00AfA38nEAAAAAQEjr7u5xuVz0AYBohoaG7HY7fQD8inwcAAAAABDSmi9coAkABCRJUktLK30A/Ip8HAAAAAAQ0hqbmmkCADE1NDbRBMCvyMcBAAAAAKGrvb1jdHSUPgAQU0tr6+TkJH0A/Id8HAAAAAAQuk6eOkUTAAjL4/GcrqqmD4D/kI8DAAAAAEJUf/8Ah6sAENyJk6emp6fpA+An5OMAAAAAgBC1Z+9er9dLHwCIzOFwvHPoMH0A/IR8HAAAAAAQiqprai9daqMPAMR38tTpzs4u+gD4A/k4AAAAACDk9PT07ty1mz4ACAiSJD3/4kvWiQlaAficil8lAwAAAACElLa29udeeJHzfAEElvj4+IcefCAxIYFWAD5EPg4AAAAACCGHjxw9cPAdSZJoBYCAEx4eftedd5SVltAKwFfIxwEAAAAAIcHpdL708qtNzc20AkBAW72qctPNN6lUKloBzB35OAAAAAAg+I2Mjj7z7PPDw8O0AkAQyMvLvf/eeyIjI2kFMEfk4wAAAACAINd8oeXlV151OBy0AkDQiIuN3f7A/ampKbQCmAvycQAAAABAMDv67rF9+w9w4DiA4BMeHr5t650lxcW0Apg18nEAAAAAQHDyeDyvv/HmmTNnaQWAYKVSqTasv+H669bRCmCW30Tk4wAAAACA4GO325957vnOzi5aASDoVZSXbb3rTo1GQyuAa0U+DgAAAAAINmNjY3/44zOjo6O0AkCIyMnOfnD7/REREbQCuCbk4wAAAACAoNLV3f30M8/Z7XZaASCkJCYkPPLIQ3GxsbQCuHrk4wAAAACA4NHY1PTSy6+6XC5aASAERUVFPfzQ9vS0NFoBXCXycQAAAABAkKiqrnnzrZ2SJNEKACFLr9dvf+C+/Lw8WgFcDfJxAAAAAEAwOHT4yP4DB0PtqsPDdUajMSIiIsJgCA8P1+l0Op1OpVKp1eqwsDCv1+v1el0ul9vtdjqd0w6HY9phn7bb7dMsGAQilUoVGRkZGXl5yRsur3iNRqNSqVQqVVhYmCRJHklyu1wut9vhcDgcjunpaZvN7na7Q6pRWq1229a7ykpLWDPAX76xkI8DAAAAAALdrt17jp84GcQXqNeHJyYmJsTHx8XFmePiTCZTbKwpKipKp9PN4tUkSbLZbNaJCavFOm4ZHxsbHxsbGxoenpycYi1BEHFxsYkJCWaz2WyOizXFmmJNppiYyMjIyzn4tZqZmZmcmrJarBar5fKCHx0dGx4ZCeLcXK1W33rLluXLlrKWgCsjHwcAAAAABDCv1/v6G2/W1NQG2XVFRkZkZmampaampaampqbExMTMLha8JtPT0wODg/39A/39/d09PaOjYywwyCY5OSkrMzMlJSUtNSUpKSk8PNzfI0qSNDY+PtA/0Nff39fX193T63Q6g6mlKpXq5ptuXLN6FasLuNJ3Cvk4AAAAACBASZL08quv1defC47LiY2NzcvNycrKysrKTIiPlyEQv7Kpqamuru6u7u7Ozq6e3l7WG3xLo9FkZWZmZ2dlZ2VlZmbo9XrF7ycDg4OdnV1d3d3t7e02mz04+rz+huvX33A96w34OOTjAAAAAICAJEnS8y+81NjUFNBXodFocrKzCgsLi4oKExMShK3TZrNdvHippbW19eKl6WmOL8fsmUymosKCwoKCvLxcxTPxj+P1evv6+1taWltaW3t7+wI9PVu7ZvXNN93I2gM+Evk4AAAAACDwBHo4rtVq5xUVlpaUFBUVynCOhG87393dfb6hsaGxkfPKcfXizebS0pLS0pKU5OTAqtxutzc2NZ8/f769o0OSAjVGIyIHPg75OAAAAAAgwARuOK5Wq+cVFZaVls6bVxRYsfiHeb3ejo7O8w0N586fn552sCzxkUwmU0V5WWlpSWpKSqBfi81ma2hsOnf+fEdHZyDWv27tmptu3MiaBD6AfBwAAAAAEEi8Xu/zL7zY0Bhg4bg5Lm7JksWLFy2MiooKshlxu92NjU01tbVt7R2sT1ymVqvnzytasnhxQUG+Wq0OsqsbGR2tqak9c7bOZrMFVuXXrVt748YNrE/g/cjHAQAAAACB5KVXXq2rqw+Yn7pVqgXz561Yvjw3N0fx523628joaHV1TXVN7czMDAs1ZEVHR69csTwoPwr6AI/H03zhwomTpzo7uwKo7I0b1l9/3ToWKvD/36nJxwEAAAAAgeL1N96srq4JiFJ1Ot3iRQsrK1fGm80hNUczMzPVNbUnTp6yWq2s2JCSkpy8elVlWVmpRqMJqQvv6+s7dvzE+YaGQDmdfMvmTasqV7JigcvIxwEAAAAAgWHX7j3HT5wUv86ICMPqVZXLly2LiIgI2cmSJOl8Q8ORI+8ODg2xdINebk7OurVr8vPzgv6XJK7AYrEcP3GyqrrG7XYLXqpKpbrj9tuWLlnM0gXCyMcBAAAAAAHhyNF39+7bL3iRer1+9arKVZUr9Xo9UxYWFub1es+dO//OocMjo6N0IyhlZmZsXL8+Ly+XVlw2MTFx+MjRmtpaj0cSuU61Wn3/ffcWL5jPlAHk4wAAAAAA0dXWnnltxxsi/wCr0+kqV65Ys3pVKO8Z/ziSJNXXnzvwziGLxUI3gkZaauqG9TcUFRXSig8bt1gOHTp85myd4HetTzzyUE52NvOFEEc+DgAAAAAQWvOFlmefe16SxN2MWVFedtONG2NiYpisK3C73ceOnzhy9F2n00k3Alp0dNTGDRsWLawI5dNUrsbA4ODuPW+3tbULW6HBYPj0448mJyczWQhl5OMAAAAAAHH19fX/5re/EzZRzUhP37JlU2ZGBjN1laampvbtP1B75iytCERarWZVZeV169aGh4fTjavU1NS8Z+/esbFxMcszmUyf/cynoqOjmSmELPJxAAAAAICgrFbrr379m8nJSQFri4gw3HzTTYsXLWQL7Sz09va+vuPNgcFBWhFACgryb7/1lri4OFpxrdxu97vHjh06fNTj8QhYXmpq6qcff5TPPBCyyMcBAAAAACKamZn59W/+e3BwSMDaSkuKb9myOSoqimmaNY/H8+6x44cOH3a7PXRDcJGREZtvvnnhwgpaMRfDw8Ovv/FmV1e3gLXNKyp66MEH+LQPoYl8HAAAAAAgHK/X+8enn21pbRWtsOjo6NtvvWX+/HnMkU+MjI7u2PFmR2cnrRBWeVnpls2bjEYjrfDJne10VfXeffsFPDNq9arKzZtuZo4QgsjHAQAAAADC2fP23nePHRetqpLiBXfcfltERAQT5ENer/fdY8cPHDzo8Uh0QygGg/72W28tKyulFb41Nj7+0suv9PT0ilbY1rvuXLxoIROEUEM+DgAAAAAQy5mzda+8+ppQJel0ui2bNy1dspjZ8ZO+vr6XXn51ZHSUVggiOzvrnm1bTSYTrfAHSZIOvnPoyNF3hcrltFrtY49+IiszkwlCSCEfBwAAAAAIpL+//9e/+a3L5RKnpNTUlHvv3paQkMDs+JXT6dy5a3ftmbO0QlkqlWr9DdevW7tGrVbTDb/q7Op68aVXJiYmxCkpOjr6C5/7Kx6ugNC66ZGPAwAAAAAEMT09/cv/+5/jFos4JS1aWHHbrbfodDpmRx41tbVv7dzFQzuVEhkZee892/Lz8miFPGw224svv9LW1i5OSTk52Y998hN8OoLQQT4OAAAAABDFH/74dGvrRUGK0Wg0WzZvWr5sKfMis76+vmeff9FqtdIKmaWnpz1w372cqSIzSZL2Hzh49N1j4pS0qnLlls2bmBqECPJxAAAAAIAQDh0+sv/AQUGKiY6O3v7AfRnp6cyLIux2+4svvXxJpE21QW/J4kW33rJFq9XSCkU0Nja98tprTqcoR0ttf+C+4gULmBeEAvJxAAAAAIDyOjo6f/v7P0iSJEIxKcnJDz+0PSYmhnlRkCRJb7z5Vk3tGVohg5tu3Lh2zWr6oKy+/v6nn3l2cnJKhGIiIiK+8Lm/io2NZV4Q9MjHAQAAAAAKs9vtP//lrwR5SF1hQf59996j1+uZFxEcPnJUnN8qCEparWbbXXeVlpbQChFYrdb/efqZoaFhEYrJzMj49Kce4yByBD3Nk08+SRcAAAAAAAp6/oWX+vr6RKhk6ZLF99y9jadxiiMnOzshIf7ChRa29/lDZGTEIw8/VFhYQCsEYTAYFlaU9/b1jY+PK17MxMSE2+0uyM9nXhDc+AgIAAAAAKCk01XVF1paRKhkzepVd9x+G5slRVNeVvbg9vt1Os7F9rGoqKjHH3s0KzOTVghFr9c//OD24gXzRSjm2PETHR2dTAqCG+/6AAAAAADFjI6O7nl7rwiVrL/h+ptvupEZEVNhQcHDDz0YHh5OK3zFZDJ96vFHkxITaYWANBrNfffeU1FepnglkiS9/OprMzMzTAqCGPk4AAAAAEAZXq/3pVdedTqdileyedNNN1x/HTMistycnEc/+UhEhIFWzF18vPnTjz8abzbTCmGp1eptW+9aumSx4pVYLJa3du5iRhDM3260AAAAAACgiKPvHuvp6VW8jC2bN62qrGQ6xJeRnv7oJx4xGHh06pyYzXGPP/pJk8lEKwSnUqluv+3WZUuXKF7JmbN1zRdamBEEK/JxAAAAAIAChoeHD75zSPEybty4vnLlCqYjUKSmpj7y0IPh4TxAdZZMpphHP/FIdHQ0rQgIKpXqtltvqagoV7ySHW+86XA4mBEEJfJxAAAAAIDcvF7vK6+97na7lS1j3do169auZToCS2Zm5oMPPKDVamjFtTIajZ/8xCOxsbG0IoCoVIIcyzgAACAASURBVKqtd95RXLxA2TImJyd37trNdCAokY8DAAAAAOR28tRpxU9WWbF82Y0bNzAXgSgvL/f+e+9Vq1W04uoZDIZHP/FwQnw8rQg4arX6nm1bC/LzlC3jzNm6S21tTAeC8FuMFgAAAAAA5DQxObn/wEFla1iwYP4tWzYzF4Fr3ryi2269hT5cJY1Gvf3++5KTk2lFgNJqtfffd29KisIz+MabOz0eD9OBIEM+DgAAAACQ1c6du2ZmZhQsICM9/Z5tW1Uqdh8HtqVLlqxbu4Y+XI277rwjNzeHPgQ0vV7/8IPbY2KUPDt+dHT00OEjzAWCDPk4AAAAAEA+ra0XGxqbFCwgNjb2we3363Q84DEYbNywvqy0hD5c2Yb111eUl9OHIBATE/PwQw/q9eEK1nD03WNjY2PMBYIJ+TgAAAAAQCaSJCn7hDe9PvyRh7ZHRUUxF8FBpVJtvevOjIx0WvFxKsrLrr/uOvoQNFKSk++9524FC3C73Tt372EiEEzIxwEAAAAAMjl+4uTI6KiCBWy9887ExEQmIphotdoH7rvXaIykFR+WkpJ8x+230YcgU1RYuGH9DQoWcOFCS0trKxOBoEE+DgAAAACQg81me+fQYQULWLtmdXHxAiYi+MTExNx3zz1qNQfK/5mICMMD99/HUUJB6bp1a+fNK1KwgF2735YkiYlAcCAfBwAAAADI4cDBdxR8LGd+Xu7GDeuZhWCVm5tz04030of3u3vbVnNcHH0ISiqV6u6td8WbzUoVMDIycrqqmolAcCAfBwAAAAD43cjISE3tGaVGj4oy3nP3NrWaH4GD2epVlfPnz6MPl61bu6aosJA+BDGDwXD/ffdoNBqlCnjn0GGn08lEIAjwHwcAAAAAAL97e+9+j8ej1Ohb77zTaDQyC0Hvrjtu5+GrYWFh6Wlp62+4nj4EvZSUlBs3KvZrMTab7fCRo8wCggD5OAAAAADAv7p7epqam5UafeWK5YWFBcxCKIiMjNx61x0h3oTwcN09d29VcFsx5LSqsjIvL1ep0U+cPGWz2ZgFBDotLQAAAAAA+NWBg+8oNXRSUuLNNwXtsdROp7Ojo6O3p7evt3dwcHBiYsJisdimppwup3PGKXm9Oq02XK+PiDCYTCZTbGxCfEJ6Rnpaenp2drbJZArKnhQWFFSuXHHi5KmQ/XbbvGlTfHx8UF6ax+Npb2/vaO/o7+8bHBgcGxu1WKwTVqvT6ZxxOt0ul0aj0el04eHhMaaYmBhTbKwpJSU1NS01PT09Lz8/Ojo6+HqiUqm23XXnz3/5q+npaUVuQUeOvrt50828zSGgkY8DAAAAAPyos6vr4sVLigytVqu2bb1Lqw2en3wlSbrQfOFcff25c+daWlp6e3pmfWpNYmJifkFBSWlJeUVFaWlpZGRk0HTpphs3trZeHBkdDcFvt6LCgqVLFgfTFfX09NSdOXvu3LnGhoaOjg6XyzXrl0pKTp4/f155eUVZRXlxcXHQ3BliYmJuvWXzSy+/qsjop6uq165ZzblGCGgqr9dLFwAAAAAAfvK73//PpbY2RYZes3pVcGwelyRpeGiovv7cW2+8UVNT4/OT3LVabVl5eeWqyrVr1+bk5gZBx9o7On77uz+E2vdaeLjuS1/8QnD8ZsDk5GRnR8fhQ4f37ds7ODDo89ePiIhYsnTpysrK62+4Pji22//x6WdaWi8qMnTlyhW3bNnMmx0CF/k4AAAAAMBfenp7f/Wf/6XI0GZz3Bc//zmdThdkLbVarfv37nvrrbeam5r88fq5eXkbNmzYvGVLWnpaQDdqxxtvVtfUhtS32y1bNq1csSL4rqupsWn3rl17du+enJz0+Yur1epFixZtvOnGm266KTKQn+JrtVp/9vNfOp1O+YcODw//xte+Eky/g4JQo3nyySfpAgAAAADAH97auWt4ZESRoe+/796EYDyF2WAwFJcU33nXnQsXLhwcHOjv7/ft61vGx2tra1968cX6+jqDISInJ0elUgVio3Kys8/W1SkSFyoiIyP9jttuC9DJurLExMTKVau23b0tKjqqpaV1xuHw4Yt7vd7+/v5j77770osv9vb2JiUnJyQkBOidQa/Xtyqxhdzj8Wg0GgUfEwrMEfk4AAAAAMAvhoeHd+7ao8jQFRXlq1dVBnd709LTb7n11vz8gnPnztlsNp+/fm9v74H9+3fv3q1WqwoKCgLusGatVmuKMTU0NobC95pKpXr4oe3RQX0GtC48vKKi4vbbb5+cnLzQ3Ozz13e73S0XLrz+2mt1Z+vMZnNGZkbAtSg9Pe1CS8vk5JT8Qw8ODa1csVyj0fDGh0BEPg4AAAAA8It9+w/09fXLP254uO6h7Q/o9fpQaHJubu4dd9ze19fX5p9D3icnJ08cP/Hmm2/odLqioqLAyr+SkpLa2tutVmvQL4Ply5YuWbwoFBa83mBYs3btwoULT508OT097Y8h+vr63t6z59SJkympqenp6QHUHJVKlZyUWHvmrPxDu91uo9GYGYAfKgBh5OMAAAAAAH+w2+2vvr5DkiT5h77h+uuKiopCp9W68PD1G9abTKaTJ076aYhp+/SJ4yd27doZHx+fn58fQM1JTUmpqq4J7gVgMOi3P3B/8B21fwVp6embNm+ur6sbGhry0xBDQ0N7du2ur6ufN39+XFxcoHTGZDKNjI76ry1XMDo6unLliqA84QdBj3wcAAAAAOB7x46fuHjxkvzjxsbG3nP3NrVaHWoNLykpycvPO3zosP8+k7BN2d45+E7V6dPFJSVmszkg2hIdHT0xMdHfPxDEU3/jxo0hePRzZGTkTTff3NrS2t3d7b9R+np7d7z2+rhlfOHChYHyCURGenpVdbX8n01OOxxpaamJgXl6O0Ic+TgAAAAAwMckSXrplVdnZmbkH/r2225JTUkJzbbn5ubm5+cf2H/Ar6MMDg6+sWOHy+WqqKgIiONWMjLSq6qrPR4pKCc93mzeetedIfiBUFhYmFar3bBxQ+P5ht7eXv+N4vV6Gxsa9+zek5WVmZWVJX5bDAaD2+3p6OyUf2jblG3RooW8AyLgkI8DAAAAAHysqflCdY0Ch1okJyfdumVLKP+Cf05OjjnefOzdY34dRZKks2fOHj1yZOGiReIfPREeHu50Oju7uoJyxm/Zsik1NTVkF7xarV53/XWnT54aGRnx60A2m23v23tHhkeWLV8u/rNq01JTq6pr3G63zONarNaK8rLIyEjeBBFgdxJaAAAAAADwrarqakXG3XDDDZx+e9fWrbfceqsMA128ePGxT3zypRdfFL8na1av0uvDg2+uExMTykpLQ3zBR0ZGfv8H/xIVFSXDWDtef/0TDz98sbVV8J4YDIY1qyvlH9fr9Qb9cf8ISuTjAAAAAABfslgsly61yT9uWlrq/Pnz6H9YWNg3nvhmpiwHQczMzPzoP374D3/394qcpXP1IiIiVlVWBt9Er7/h+tA8WeUDUtPS/vY735ZnrM6Ozk8//qm39+wRvCcrV6yIjIyQf9wzZ+s8Hg9rEoGF2ygAAAAAwJfOnK2T/9FwYWwefx+DwfDEt56Qbbh9e/d++rHHhwaHRO7JqsqVBoMhmGY5OTmppLiY1X7Z+g0bVq1eJc9YDofjyX/47s9+8lORG6LX69esXi3/uDabrflCCwsSgYV8HAAAAADgS2fr6uUfNDk5qbCwgOa/Z+myZRs2bpRtuNbW1k899lhLi7i5mMFgWL5saTBN8bo1a/hA6P2+9o1vyHky+HPPPvs3T3xL5N+cWL5sqV6vV+At4GwdqxGBhXwcAAAAAOAz3d09o6Oj8o+7ZtUqssIPePxTj8s53PDw8Of/6rNnas8I25CVK5ZrNJrgmFyTKaakhM3jfyY9PX3Tls1yjnj40KEvffGLNptNzIbo9fplS5fIP25La+v09DQLEgGEfBwAAAAA4DNn6xTYORgdHV1WVkrzPyA3L2/ddevkHNFms33tK185dfKkmA2Jjo4uLy8LjsmtXLkyaLJ+H3rkkUdkHrG+rv6Ln/v8hNUq6jpZodHIHf15PJ5z5xtYjQgg5OMAAAAAAN/wer0NjU3yj1u5cgVZ4Ue67fY7ZB7R4XA88Y1vVp2uErMhq1cFw1M69Xr90iWLWd4flpmVtWix3J1pbm7+8l9/Scxd5DExMaWlCnx2eJ58HAGFfBwAAAAA4BudnV1TU1MyD6rTackKP87KypWxsbEyD+p0Or/1zW/W19cL2JDkpKT8/LxAn9bFixYqcq50QNgs7xErlzU3N3/1y19xOBwCNmTVyhXyD9rR2SnssTPAh5GPAwAAAAB843yDAnsGS4qLIyIiaP5H0mq1KysV2DE9PT39za99vbOzU8CeBMGnKXwgdAWrV69RZNxz9fXf+dtvS5IkWkPS0tJSU1NkHlSSpMamZlYjAgX5OAAAAADAN5qaL8g/KFnhX+jP0qWKjDsxMfG1r3x1fHxctIYsmD/faIwM3AnNysxMSkoSrSq73S5IJeZ4c26eMr8icPzYsR/++3+IeBNYosBTOhuVOGsLmB3ycQAAAACADwwMDFplf0hdYkJCdna2aK04V39OnGJKlHtyaV9v79888YTH4xFqdjQazcKKisD9Rlsi3gdCg4ODBoNBnHoUOXH7sldfeeXVV14RbYIqyst0Op3Mg7Z3dLhcLt4ZERDIxwEAAAAAPnChpUX+QQXMCk8cP2GxWMSpJyMjQ8GHl9bX1f/kxz8WbY4C93cO9Hp9WWmJUCU5nc6nfvoztVqgfCknJ0fB0X/yox83nD8v2rIplX3ZuN3ui5faeGdEQCAfBwAAAAD4gCL5eLlym6M/0vDQ0Pe++93MzAxxStJqtSmynz78fi+/+NKB/fuFmqaEhIS0tNRA/C4rXjBf/o3AV/bjH/3I7XYLVVKGot+ALpfr23/77cnJSaF6UlFeJv+gLUq8KQCzQD4OAAAAAJirmZmZ3t4+mQfNyc6Ojo4Wqg/fe/J7Vqs1OiZGqKqioxWu51//5QdDg0NC9US0XdhXqVSwso8eOfL6q69Fx0Sz4N9vaHDwB9//vlA9yc3Jkf/Y/UvsH0eAIB8HAAAAAMxVR2en/MdMi5YVPvvMMzXV1WFhYREREUIVZoxU+HGUk5OT//jkk0L1pKQk8PLxiAhDvkJPnvxI4+Pj3/8//xwWFmaMNArVqEgBnr968MDB3bt2idMTtVpdUlws86Bj4+NCHTYFfOw3CC0AAAAAAMxRW1u7zCOqVKqS4gXidKC3t/e//vPX79Um1vQIUE9NTc2O13eI05K42NiM9PTA+i4rXrBAwaPkP+zHP/zhn9JP4da7EAX99Mc/GR8fF6ctpUp8JiT/WwMwC+TjAAAAAIC5amvvkHnE7OysqKgocTrwg+//i8PhuPz/2+12oWZHkHp+8dRTo6Oj4rSltLQ4sL7L5N//ewXHjx3bt3ffnxaYTbAFb7OJUIbVav3Rf/xQnLbk5GQbjXLv9G/r6AgDhEc+DgAAAACYE6fTOTg4KPOg84oKxenAgf37q6uq3vufoj2ab0qMeiYnJ3/x1FPitKWosDCAvst0Om1ubo4gxbjd7h//8Ef/f4FNibXgJyenBKlk/759tbW1ghSjUqkKCwtkHrSrq5u3SIiPfBwAAAAAMCc9vb2SJMk8aKEw4ebMzMzPf/ZnsW9Pd484s+PxePr7+wUpZs/uPQ0NDYIUk5iYGBtrCpTvstzcXK1WK0gxzz/3XE9Pj5gLPiwsrKdHoEz2Jz/6sdfrFaSYItnz8bGxMZsY2/mBKyAfBwAAAADMSbfs6VhMTExyUpIgl//C8y8MDAy8/0+6OjvFmZ2+3l632y1IMV6v96mf/FSc5hQWFATKd5n8yebHmZiY+P3vfv/nd4BucSJg0b4BW1tadu0U5UGdBfn58h/O3tXNFnKIjnwcAAAAADAnPT29Mo8oTlZot9ufffrpD/xhQ8N5cWZHnP3al9XV1Z06eVKQYgLoiBVxovxnn37aNvVnB5g4HI5Lly6JtOYbhZq73/73f3s8HhEqiYiIyMiQ+7G08r9BANeKfBwAAAAAMCf9f757Wgb5+XmCXPsLzz9vtVo/8Ie1NbXibKetqa4WbcH813/+WpBKcnNz1GqV+N9icXGxZrNZhEqsVutLL770EcusSpRlZrVaW1tahJq+vt7enW+9JUgxBfn5Qf8GAVwr8nEAAAAAwOxNT09bLBaZB83OyhLh2mdmZl58/oUP/7nFYmlsFGIHq8fjOXnipGhrpqGhQZCHFur1+uTkZPG/ywRZ8GFhYa+89LLdbv/wnx8/fkyQCk8cPyHgDD7z9DOCVJKVlSnziP395OMQHfk4AAAAAGD25N8bGBsbGx0dLcK179q58+M+G9izS4gTh2uqq0dGRgRcNs/88WlBKhEner6CLDGKdDqdL7/00kf+q6rTVcPDwyIUKci33gd0dXYePXJEhEoyMzJkPoJ8cnKSR3RCcOTjAAAAAIDZGxqSOxTLln3/48f5yM3jl+19e6/D4VC8wjd2vCHmsjlx/HiPGE/tyxJmOYlf5L63946Pj3/kv/J6vbve2ql4hQMDA6dPnxZzEl/4+NuFnPR6fYrsvzMxJMZnJ8DHIR8HAAAAAMye/NuTBdlLW1dX19HR8XH/dmJiYsdrrytbYU9398EDB8RcNl6vV5DsXvz94waDISkxUYRKduzYcYV/+8Lzz8/MzChb4TN//KM4R/9/QG1NTU9PjwiVyP9xy8jIKO+VEBn5OAAAAABg9uQPPjIz0kW48Dde33HlL3jm6aeV3UL+u9/+TtisMCwsbNfOnR6PR/EyYmJiBDmu5+NkZKTLfCDGR2pvaztXX3+FLxgfH3/t1VcVrHB4aEjYX5gICwvzer1vilFeZkaG3FPD/nGIjXwcAAAAADB7I6Oy5uMajTopKUnxq3Y6nYfeeefKXzM8PPz73/1OqQrPnzu3a+dOkVfO6Oho1ekqESpJS00RuVGpKUKU9/bbb//Fr/nNf/1mbHRMqQp/8uOfOJ1Okady71X0UI4VJfuCl/ltArhW5OMAAAAAgFmSJGliYkLOEZMSkzQajeIXfvzYcbvd/he/7Jk/Pt3e1iZ/eS6X69/+9d/EXz8H9u8ToYzU1FSRu5QqRny/f99fnizb1NSPf/QjRco7cfy4sKcJvWdgYOD8uXOKl5GQkKDVauUc0TJu4e0SIiMfBwAAAADM0sTEhCRJco6YlJwkwoVfZRLndrv/7jt/J/+hzL946uetLS3ir5/Dhw6LcMRKclKSyF0SobwLFy709vRezVfu37fvzTfkPkVkeHj4H5/8XkDcMw8IEOKr1erEhAQ5R7RYrbxdQmTk4wAAAACAWZI/9RDhQYWSJJ06efIqv7jt0qV/+efvy3kO+P59+154/vmAWD+Tk5MibKdNTEoUtkVqtTo+Pl7xMk4cP371X/zDf/+P5qYm2WpzOp1//+3vWCyBsUP5mjrpxxupvGve6XROT0/zjglx77S0AAAAAAAwOxPWCZlHlHnb40dqON9wTafKvL1nz89/9pQ8tZ0+ffp7330ygJaQCHFhvNkswgMwP5I5Lk6EA4VOHj9x9V88MzPz1S9/pburS4bCPB7Pd//+H+rq6gJlwXd2dPb39SleRoLsN1Kr7G8WwNUjHwcAAAAAzNKUzSbziOZ4s+JXXXX69LX+lWefeeYXP/+5v3eRnzp58lvf+Kbb7Q6gJXRagEd0arVakylGzP6IsOCnp6cbGhqu6a9YLJYvfuGLHR0dfi3M5XJ977vf/YtPyhVNVZXyaz7eLPe6ssn+ZgFcPfJxAAAAAMAsTU1NyTyiOS5O8auun9Vm1af/54///E//x+Vy+amqPbt3f+NrX3c4HIG1hFpbWuQ/n/0j1pXZLGZ/RFjwDefPz+JDl6HBwc9++jP19fX+u/l882tf37d3X1igqa+rV35dyf65yxT5OARGPg4AAAAAmCWb3S7ncEZjpE6nU/aSvV7v+fPnZ/d3d7711mce/1Rvb69vS5qZmfnXH/zge999MrB2jl/mdruvdW+yP8SaTGL2JzY2VvEaZp3nWq3Wz//VZ5/549M+/82J5qamTzz8yKlTpwLxtlkvwGkw8i949o9DZOTjAAAAAIBZmrbL+sg1U4zyIWZXV9dcgp7m5uaHtz/47DPPeDwen9RTdbrqkYcefv3V1wJ3FTU3Nileg0nUfFyEg1+am2c/QR6P5+dPPfXXn/9CR3u7T4pxOBy/+uUvP/34p/p8/TmTbHp6ehQPiyMjI7VaWc+1t8v7YSpwTcjHAQAAAACzNOOU9WSMmJhoxS/5YmvrHF9henr6qZ/+7OHtD+7ft1+SpFm/zoXm5m9984kvffGLXZ2dAb2KLl5sVbwGEZbWxxQWI8CavzjHV6ipqXlo+4P//q//1t/fP+sXcTqdr7/22n333PuH3/8hEH9V4j1er/fixYvK1qBSqWKiZV1aTqeTd0wIS0sLAAAAAACz45yRNfKIiopS/JIvXbzkk9dpb2//++9859e/yrztjts3bdqUmJR0lX/R4XAcPnRo51s7Z/GYUDFd9FFL57S0jFFiNifKaFS2ALvNNjAwMPfX8Xg8r77yyo7XX9+wceOWW7YsXbZMo7na/cvdXV17du95Y8eOkZGR4Fjzly5erKioULYGo9E4Nj4u23AiPGYA+Djk4wAAAACAWZI58jAqnRWGhYV1d3f79tV++fNf/N9f/HL+ggVLly4tKy/Pzc1JTUv7QHQ4Ojra2dHR3NRcXV11pvZMwD2E88p6fNrSWS6tKKOYzVF8zXf39Pjw9HCPx7P37bf3vv12XFzc0mXLlixdWlRUlJ2dFfnnl+nxePr7+tra2s6cOVN9ukrx3daC30ZmJ0reNT8zw/5xiIt8HAAAAAAwS24fHaJ9lSIiIhS/5P6+Pp+/ptfrbWpsbGps/NMP6lptVFSUMcqoVmvsdpttyhZkgfgHTE9PWywWZR9EKcLS+jCNRq3X65Ve8P3+eNnx8fF9e/fu27v38v80mUxGo1FvMLhdLpvNNjExEdAnqCjVVZHXvMcTzBOKQEc+DgAAAACYJUnefNxgMCh+yXM5QPkqud1ui8VisVhCZyH19/UrnI8LsLREXfB9MoxitVqtVmsILXhZuirU6vLM4VkLgL/xfE4AAAAAwCzJHHkYDHrFLzmkYmvZjI+PKVuA4tu0ha1qfGyc9RmUXZU5H5c85OMQF/k4AAAAAGCWJHnzcZ1Op+z1TkxMSOyC9APF9w5rtVqVSiVaWxRf8CJMDQs+OFaX5OXOCXGRjwMAAAAAZvsjpVrWHyqVz8fJCv0jBOPCQClpYmKC9elzTqdT8YcK6HSyHrmsVpFAQuD/mKEFAAAAAIDZ0Wg0cg6nlXe4D5txOpl0f3DOOENtMQdKSTMzDtanf9b8TEitLrWGBBLiYnUCAAAAAGZJI+/+cZVa4Z9hXeTj/uF0Kd9YtVq481VE2HLrcrlZn/5Z8y6lF7ysq0uj1jDpEBb5OAAAAABgtj9SyrwDUekTot1ussKgbayA54+LENmz5oO1sTIveA37xyHyf8zQAgAAAADA7Mj+hDevster1WqZ9GBtrFfp1fURC15SviQBj51hzQfighfwfH/gPeTjAAAAAIBZMhj0cg7nlSRlr1dLxOMfOq3yjRUhjP5gSV5J8RrCw1nz/lnzSt9MZF7wBoOBSYewyMcBAAAAALNk0Msaebg9HqWvV8+k+4PeoHxjPUqvrg+TPCLk46x5PzU2PKQWvJ6bJwRGPg4AAAAAmCWZ94+7lX5UYHRMDJPuDzECNNbtdonWFpfLxdQEJZ1OFxEREVKri/3jEBn5OAAAAABglmSOeBSPC2NiYtRqfo72PZPJpGwBHo9HwPNVRMjHTbEm1mfwLXj5V5finwcAV8D7OgAAAABglqKiouQczjHjUPZ6VSqVCMFW8Ikzm5UtwOFwCNgWx8yM8lMTF8f6DMquzsi7uqKjo5h3CIt8HAAAAAAwSzHR0XIOJ0KImZKayrz7vqspKcoWIGg+7phWvIZUFrw/upqWKsDqknXNR0dFM+8QFvk4AAAAAGCWouXNx+124sIgZDAYzErvH5+enhawMx6P5HQ6WfDBJzU1TfEa7PKuefaPQ2Tk4wAAAACAWYqOkTUft9lsil9yZmYG8+5bGRnKt3RKgKUlZmEZmZksUT90Vfk1b5uSb2lpNBqj0ci8Q1jk4wAAAACAWYqLjVWpVLINJ0KImV9QwLwHX0unpgTNx21TU8oWEBUVlZSczCr18ZrPF2DN2+RbWiaTSc53CuBakY8DAAAAAGZJq9XKecTKxMSE4pdcQD7ua/kF+YrXIMLS+ujCJidZ86x5n/N6vZMyLi2zmae8Qmjk4wAAAACA2ZMz+LBalQ8xs3NyIiIimHcfmj9/geI1CJuPi7Dm5y+Yzyr1obS0tJiYGGVrmJ6edrncsg0Xr/QDBoArIx8HAAAAAMyenE9WtNlsbrdb2etVq9UlpaXMu69oNJrSMuX7abFaxeyPxWJRvIby8nIWqi/7WVERagveTD4OsZGPAwAAAABmLykxUc7hxsbHFb9k4kIfKigoEGE//tjYmJj9EWHBl5WVqdXER767gVQofwMZG5V1wScmJjDvEBk3OAAAAADA7CUnJ8k5nMyxzkdatnwZ8+4rSwVopsfjsYq6f1yEBR9pNC5YsIC16rMbyDLl1/zYuKzrKplHvEJs5OMAAAAAgNmTOfgYGR1R/JLLysuNUVFMvU9UVlYqXsPo2JgkecXsz9j4mCRJyk/TqlWsVZ/IyMjIyMxUvIzhYflupBERESalz1sHrox8HAAAAAAwezHR0ZGRkbINNzg0rPglazSaFSuWM/VzZzQaFy5apHgZwwIsqo/j8Uijo6OKl7Fq9WqWq08I8knD0LB8a17m3zECZoF8HAAAAAAwJ6kpKbKNNTQ4JMIl37B+A/M+d2vXxR3fMgAAIABJREFUrdNoNIqXMTg0JHKXhgSI7xcUL0hNTWXFzt36DesVr0GSJDn3j8v5BgHMDvk4AAAAAGBOMjLSZRtraHjI4/Eofslr1q4xGAxM/Rxt2LhRhDL6BwZE7pIg5a3fyGdCc5WQkCDCL0yMjo25XC7ZhsvMyGDqITjycQAAAADAnGRmyhd/uN2ekRHljyA3GAxr161j6ufCFBu7snKlCJX09/eL3ChByrvp5ptZtHN04003heCKkvMNApgd8nEAAAAAwJzIvD2wu6dHhKu+4847mPq52Lxls1arVbyMyclJq3VC5Eb19PZ6vco/PrSoqGj+/Pms27m4XYybRk9Pr2xjGY3GuLg4ph6CIx8HAAAAAMyJ0Wg0m82yDdfV1S3CVS9ZujQzM5PZnx2VSnXHnXeKUIkgy+kK7PbpEQEe0RkWFnbHXXeydGetoqIiJydHhEo6u7pkGyuLzeMIBOTjAAAAAIC5ys3NkW0scQLNu++9h6mfnWXLl4VgVjiHNS9EkZs2b46JiWH1zs49990rQhlOp3NAxhPtc3NzmXqIj3wcAAAAADBX+TKGIKNjY1NTUyJc9e133BEdHc3sz8L2Bx8UpBLx94+HhYV1ilGkwWC4a9tWVu8spKWl3bB+vQiV9PT0SpJ8x/XkkY8jEJCPAwAAAADmKi9P1hCkS5i4cNs9dzP716qwqGjFSiGezOl0Ovtl3Es7+wXfKcom93vvvU+v17OGr9UDD25Xq4WI4Lq65VtLkZGRKSnJzD7ERz4OAAAAAJirqKioxMRE2Ya71NYmyIVvf/DBqKgoFsA1+fRnPiNIJe0dHZIkid+x0bGxcYtFhErM8eat27axhq9JUnKyIKfth4WFXbwo382TzeMIFOTjAAAAAAAfmFdUKNtYLa0XBbnq6OjoB7ZvZ/av3oLi4rXr1gpSTKswC+kvunhRlFIf+eQnIiIiWMlX77HHHtPpdCJU4nA4unvk++WbIhnfFIC5IB8HAAAAAPjAvHlFso1lsViGR0YEufDtDz0o5975QPelL39JnGJaLwZMPi7OZ0KxsbEPP/IIK/kq5ebm3nr7bYIUc6mtTbbDx9Vq9TzycQQI8nEAAAAAgA9kZ2XJuatUnJ2/BoPhc1/4PAvgaqzfsGHhokWCFDM6NjY2Nh4orWtra/d4PIIU8+DDD6WkpLCer8ZXvvZVjUYjSDFy3jbT09KMRiMLAAGBfBwAAAAA4IsfL9XqwoJ82YZraW0V59o3b9lSVl7OGriyiIiIvxZp83hLS2sAdc/pdHZ0dgpSTHh4+Je+8hWW9F+07rrrlq9YIUgxXq9Xzt9CmD9/HgsAAfMfMLQAAAAAAOATJSXFso3V3t5ht9vFufZvf+fbghwxLKy/+uxnhdp03NDQGFgNFKrgG9bfsO66dazqKzBGRX3jiW+KU093d/fk5KRswxUXL2ANIFCQjwMAAAAAfGNeUVF4eLg8Y0mS1NDYJM615+TmfvLRR1kDH6e0tPTe++8Tp56JiYnOrq7A6mFDY5MkSeLU840nnoiKimJtf5zPf+HzQj2Z4Nz5BtnGSklJTkxIYA0gUJCPAwAAAAB8Q6vVyvk79ecbGoS6/E8+9mhpaSnL4MMiIyO/+4/fU6lU4pR0PtA2j4eFhdnt9rb2dnHqSUxM/Oa3nmB5f6TKVZVbt20Tpx6v19vQKN+aL+NOiIBCPg4AAAAA8Jmy0hLZxmpv77DZbAL9gK1Wf++f/olH0n3Y177+9YyMDKFKOn++IRA7KVrZN91886bNm1nhH2A2m//uH/5BqJI6OjsnJ6dkG65UxjcCwAdv37QAAAAAAOArRYWFkZGR8ozl9Xrrz50X6vL/H3v3HR/XXef/fs6cMr1o1GWry5LcQ5zEKSQhTk8oAZyEsvwusHeXspXdy5bH7j4uv+1sgd9elrqQEEJCOpAE0pw41SWusS13W7LVuzS9n/uHwBjHcTSa0ZnvmXk99/FgbSPN+erzPXO+6H2+8zkNSxr+5u/+VqiN0kV32+233/6B9ws1pKmpqf6BATMW8+ChQ+l0Wqgh/cVf/WVrayvn+RmyLP/9P/5DIBAQalT79u037FiNS5dWCvbjAxdGPg4AAAAAKBhZltesNu6T9bt27RatAtdt2PCJ3/kkZ8Kcrq6uv/zrvxJtVLt27zFpPWOx+EGR2u5bLBaHw/Gv//ZvLhqR/9rnv/iFdZdcItSQksmkkbcSL774PZwGMBfycQAAAABAIa0zMBwZHRsbEG8j8Bf/4A+uvOoqzoTq6up/+4//MOyRrfOUzWZ379lr3qru2LVLtCE1NTf9/T/8vSzLnPO33Hrr73zqU6KNav+BnmQyacyxVFU18hYpUBDk4wAAAACAQqqvr6+rqzXscDvF20JutVr/6V/+ubu7u5xPA6fT+R9f/1pNbY1oAzty5Gg4HDZvYfv6Tk1OToo2qiuvuupLf/7nZX7pu3jdxX/zd38r4MB2GnhPZcXybpvNxjoIcyEfBwAAAAAU2KUGthfYf+BAIpEQrQJ2u/0/v/71xsbG8jwBNE37l6/+a2dnp4Bj27l7t9nLK+A9IYvF8tGNH/3MZz9bthe9zq7Or/77vyuKItrARsfGBgYGDTvcJZesYwWE6ZCPAwAAAAAK7D0XrTVsC2Eymdq9R8R20oHKwDe+9c26urpym31FUf7hn/7xsvXrBRzbxOTk0aPHzF7hXbv3pFIpAQf2+5//3N0f/1gZXvFaWlr+6xvfcAvZhH3r1m2GHau2tqa1pYUVEKZDPg4AAAAAKDBN095z0VrDDrdl67ZsNitgHWpra7/57W83NDSUz9Srqvr3//gP11x7rZjD27JlawkUORaLiXlPyGKx/OmXvnTX3XeX1eWuta3tv7/9Lb/fL+DYwuHwW/v2GXa49ZddxvIHMyIfBwAAAAAU3vr1l0mSZMyxZmZmew4eFLMODUsavvO97zY1N5fDpNvt9q/++79dt2GDmMOLRqN79r5VGqXeskXQe0IWi+VLf/5nn/7sZ8rkQtfd3f3t736nsrJSzOFtf3NHOp0x7O1v5G1RoIDIxwEAAAAAhVddVdXR3m7Y4d54Q9x9wdU1Nd/7/v+sXrOmtGfc5/f/139/44orrxR2hNvf3JFOp0uj2lPT04cOHxZ2eJ/7/Oe/9Gd/ZrWWeOi0fv36b37n2z6fT8zhpVKp7W/uMOxwl6y7WFVV1j6YEfk4AAAAAGBRXH31VYYda3Bo6OTJXmFL4fP5/vtb39xw/YZSnevGpqbv3/ODNQLfA0gmk9u2v1lKNX/ttTd0XRd2eHd97O5//bev2u32Uj3n3//BD/zn//m60+kUdoQ7d+2OxWLGHEuW5SuvuJxVDyZFPg4AAAAAWBRtra1Llywx7HAvvrRZ5GpomvZP//Ivn/vC52VZLrGJvvKqq+754b1Lly4VeZDbtm+PRqOlVPbBoaEjR4+KPMKrr7nm+/feI/iJsQCKovw/X/7y3/zt34r8Xk6lUq++9rphh1u7ZrXX62XVg0mRjwMAAAAAFouRW8hP9/cfO3Zc8IJ8+jOf+dp//R9huxXnSlGU3//c5/7z619zu90ijzMej7/+xpbSe3+9+NJmkbeQWyyW9vb2e3903zXXXlMyNa+tq/3Wd77z0Ts3Cj7O7W/uCIfDxhxLkqSr33uVBTAt8nEAAAAAwGJZsXx5dXW1YYfb9NJLgseFFovlsssuu//BB668yvRx0pKlS77zve9+5nc/K/5Qt2zdFovFS+/9NTIyevDgIcEH6Xa7v/rv//7lv/yLEui1suH66+9/4IHVa1YLPs5EIvHa628YeJ3vNvI6DxQc+TgAAAAAYLFIkrThfdcadrihoeHDh4+IX5aKior//PrX/vbv/s6kHQmsVuvGOzfe/8ADK1etEn+00Wh0y9ZtpfoWe3Hz5mw2K/44P/LRj953//0XXXSRSevs9/v/3//9v//pX/7Z4/GIP9qt24zrJiRJ0obr3sdiB1MjHwcAAAAALKLVq1fV1NQYdrjnXnghk8mYojK3f+D9P3n44RtuvNFcE9re3v6d733vz7/8ZYfDYYoBv7T55UQiUarvr/HxiZ27dptiqE3NTd/+3nf/8q//yly3hSRJuv3973/40UduufUWUww4FAoZuXl85YrltbW1rHQwNfkrX/kKVQAAAAAALB6X03mg56Axx4rFYna7ramx0RSVcTgdG67fcOmllx47emxyclLw0fr9/j/6kz/+67/5m7q6OrOce2NjYz978knhm+7kZWBg8NJL1imKYorRdi9f/qE77ojHYkeOHBG/G9LKlSv/+av/uvHOjTbzNIf5xTPPDg4OGnMsq9V6150b3W4XyxxMjXwcAAAAALC4ampqDh0+YtjD4voHBtdd/B5N08xSn7q6ujs+8uGWlta+3t6ZmRkBR+h2uz/9mc/8/T/945q1ayVJMtG59+jjT0xNTZf2+yuVSmUymWUdHWYZsM1mu/Kqq66/8YaZmZm+vj4xU/LW1tYv/+Vf/MmXvmTkx1/yNzg09PTTvzTscGvWrL7s0ktY42B2kl7ad1EBAAAAAAI4ceLkvff9yLDDXbLu4g998AOmq5Ku6y9u2vTA/T8+fPiwIEMKBAIb77zzzrvvcrvdpqvn4SNHHnjwoXJ4f1mt1j/6gy9UVVWZbuQnT5780Q/ve3HTpnQ6LciQuru7P/mp37n+hhvMdSto7gLy/XvuPX2635jDKYryp3/8h36/nwUOZkc+DgAAAAAwwn0/+vGx48cNO9zv/9+fbTRJl5W327Vz5+OPPfbaq68VMTRcuXLlhz58xy233qqqqhlrmEwmv/HNb83MzJbJ+6u1peUzn/5fpot054yNjj326KO/ePrpqampYo1BUZSrr7l64513XrxunVmvG7v3/OznTxp2uPdedeUtN9/E0oYSQD4OAAAAADDCyMjot77z3Ww2a8zhaqqrv/iFz8mybN6KzczMPPvMM5uef+HgwYOG/fJeV1d3/Q033Hr7be3t7aY+35559rktW7eV1Vvsjg99YN3FF5t3/JlM5tVXXnn2mWe2b9tu5CNVO7s6b7zppttuuz1QGTBv9cLh8H9945vxeNyYwzkcjj//0p/YzdOWHbgA8nEAAAAAgEF+9uRTO3fuMuxw173v2g3Xva8E6jY8PPzKyy9v3bJl7569yWSy8NGAJHV0dFx51ZVXvffq1WtWl0DFBgYHv/c/Pyi3xMNut//JH/2BGTvhnCMajb7x+utvvP7Gtm3bZhenI7+iKGvXrr38yived911S5cuLYHZf+iRR3uMegyyxWK5/bZbr7h8PYsaSgP5OAAAAADAINFo9Ov/9Y1YLGbM4WRZ/uIXPldTXV0yBYzH4/v27dv/1r79+/cfO3o0n2YUDoejvb195apVa9auWXvRRZWVlSVTpUwm8+3vfm90dKwM32IrVyz/2N13lcyPo+v6kcOH9+7du3/f/oM9PaOjo/mkWC63u6urc83atatXr77oooucLlfJFOrQ4cMP/uRhww5XW1v7h1/8vEmb+QBvRz4OAAAAADDO9jd3PPX0Lww7XEN9/e//3u+ausvKBczMzJw8cWJwcHBkeGRsbDQYDM7MzITDkVQymUgm9WxWVVVN0+wOh8/n8/v9VVVV9fX19Q31zS0tS5YsKdVz7IVNL7762utl+xa7c+NH1qxeXZI/WjQSOXHiZF9f78jwyNDQ0MTExOzMzGwwmEwkkslkKpWSZVlVVc2meb0+n9fr8/vrG+rr6+qXNi5ta2+vq6srybJEIpH//ta3w+GIYUf83c9+urWlheUMJYN8HAAAAABgHF3Xv/nt746MjBh2xKvfe9VNN95A5ctE36lT99x7XzlnHTab7Q+++PkKv5+ToUyuqA/85KEjR44adsTVq1fdfedGKo9SYqUEAAAAAADDSJJ0xwc/YLUa99voa6+/0dvbR+XLQTwef+zxJ8p8I2AikXjs8ScMexAuimvHzp1GhuN2u/32W2+h7Cgx5OMAAAAAAEMtXbpk/WWXGnnEx574qWFNz1FETz719OxskDqcPt1fzh1mysf4+Pizzz1v5BFvvunGEngALHAO8nEAAAAAgNFuvOF6n89n2OGCweDjT/yU/qKl7c0dO/Yf6KEOcza//PLJk73UoYQlk8mHHn40lUobdsSW5uZLL1lH5VF6yMcBAAAAAEbTNO0D77/dyCMeOXrs5VdepfKlqn9g4JfPPEsdzshm9UceeywYZDd9adJ1/ac/+/nY+LhhR1QU5Y4PfYDKoySRjwMAAAAAiqC7q/M9F6018ogvbX756NFjVL70hMPhnzz0SCZDx+3fEolEH3zo4XQ6TSlKz5atWw/0HDTyiNdvuK6qqorKoySRjwMAAAAAiuP22271eb1GHvGxJ56Ympqi8qUkk8k8/MhjoVCIUrzd4ODQL375DHUoMSd7e59/YZORR2xqanzvVVdSeZQq8nEAAAAAQHHY7fY77vigJEmGHTEWi9//4wd5VmcpeerpX/SdOkUd3snOXbu3bN1KHUrGxMTEQw8/ks0a9zQFTdM++uE7jLxQAwYjHwcAAAAAFM2yjg6DH/g2MTn54EMPZzIZil8CXnn1tV2791CHC3vm2ecPHjpEHUpAJBK5/8cPxmJxIw960403VFZWUnyUMPJxAAAAAEAx3XbrLTU1NUYesa/v1E9//qSu6xTf1PbvP7DpxZeow3w89vgTA4OD1MHUUqnUAw8+NDU9beRBu7u6Ll9/GcVHaSMfBwAAAAAUk6Iod9+5UVVVIw/61lv7iFZNrbe374mf/Yw6zFMqlf7xAz+ZpPm+aWWz2ccef6J/YMDIg3q93o98+EMUHyWPfBwAAAAAUGS1tTU333SjwQd99bXXX3v9dYpvRv0DAz9+8CfpNE1ychCJRO794X2zs7OUwnR0Xf/pz35+8NBhIw9qtVo3fuTDTqeT+qPkkY8DAAAAAIrv8vWXrVyx3OCDPv/Ci9u2v0nxzWV4ZORH9z+QTCYpRa5mZ4P3/PC+UChEKUxE1/Wnnv7F3rf2GXzca6+5uq2tlfqjHJCPAwAAAACE8JEP31Fl+FPgfvHLZ3bv4QGPpjE+Pv7D++6Px+OUYmGmpqZ/eN/90WiUUpjFc8+/sGPnLoMP2tHevuG691F8lAnycQAAAACAEGw22yc+fremaQYf96c/e9L4+AkLMDIy8oN7f0i2m6ex8fEf3PvDcDhMKQSn6/ozzz73xpatBh/X7/PdfddGSZKYApQJ8nEAAAAAgChqamo+9MEPGH/cJ596esvWrdRfZAODg/f88L5IhHC8AMbGxr9/z730IheZrutPPvX0lq3bDD6uoigf+9hdDoeDKUD5kL/yla9QBQAAAACAIOpqaxOJRH//gMHHPX78hCRJrS0tTIGA+k6duu9HP04kEpSiUGKxWM/BQ11dnU6SUPFks9knfvqzPXvfMv7Qd3zwA11dnUwBygr5OAAAAABALB3t7f0DA1NT0wYft7evL5FIdLS301hAKIcOH/7JQw+nUilKUViJROJAz8H2tlaPx0M1xJFKpR5+5NGeg4eMP/SVV1x+zTVXMwUoN5Ku61QBAAAAACCUeDz+ne/+z8TkpPGHXrG8e+NHP6KqKrMggm3bt//ymefILhaPpql3bdzIlmFBhMPh+x94cGho2PhDt7e3ffp/fYq7gyhD5OMAAAAAABFNTEx8939+EIvFjD/00iVLfueTH3e5XMxCEc09nHDrtu2UYrFJkvT+22+97NJLKUVxjY2P3//jB2ZmitAXvqqy8vOf+z273c4soByvgeTjAAAAAAAx9fb13fejH6fTaeMPXVHh/+THP1ZbW8ssFEUikXjs8ScOHzlKKQxzxeXrb7n5JqvVSimK4tjx4488+lg8XoQm+y6X63O/97uBQIBZQHkiHwcAAAAAiGvvW/sef+KnRfnVVVXVD3/og6tXr2IWDDY+Pv7gQw9PTExSCoO1tDTffedGt9tNKYyk6/orr7720uaXi3Wh++yn/6/GxqVMBMoW+TgAAAAAQGgvv/LqphdfKtbRr7h8/c033SjLMhNhjJ6eg0/87OfJZLIgr+ayJW5cvr+U6jMVcb96rHvxXt/j8Xz8Y3c1LiUtNUgikXj8iZ8eOnykKEe3Wq1337Vx5YoVTATKGfk4AAAAAEB0P3/yqR07dxXr6M1NTXdu/IjP52MiFlUmk3n+hU1btm4r7Mt+6vLXumqHS6ZKP9lxZc/Q4obXsizfcvNN6y+7lEc1LrbhkZGHH3l0cnKqWAO4/bZbr7h8PROBMkc+DgAAAAAQna7rDz/y6IGeg8UagN1u/9AH379q5UrmYpGMjY8/+tjjIyOjBX/lGk/wD697ziqVQvpxeqrqe69tMOZYncs6PnzHh+i1snjXtDe2bN304ouZTLZYY3jftdfccP0G5gKQv/KVr1AFAAAAAIDIJElavry7v39genq6KANIp9M9PQdnZmba2loVRWFGCkjX9Td37Hz4kUeCwdBivH4kafM6Ykv806YvlMXyyM4rZmNOYw43OTW19619NdXVlZWVnKWFFQwGf/LwIzt37iriptXLLr3k1ltuZi4AC/vHAQAAAABmkUwm77n3voHBwSKOoaLCf8cHP9jW1sp0FMTs7OzPn3r62LHji3oUty3+Zzf8UlPSpq5Vz9DSn+y40vjjXrLu4ptvutFut3O6FsTevW/98tlnY7F4EcewauXKu+/aSP8cYA75OAAAAADANGKx2A/uvW9kZKS4w7j4PRfdcvNNDoeDGVkwXde3bX9z04svFepRnBe2oatnQ3ePecuVyVr/v5dumYwUp9uJx+N+/+23rVi+nPM2H9PT008+9fTxEyeLO4zurq5PfPxuq9XKjABzyMcBAAAAAGYSjUa/f88Px8bGijsMt9t1+623rlpFR/KFGB0b+/nPn+ofGDDsiJqc/tINv/TY4yat2NaTy36x/z3FHcOK5d3vv/02j8fDCZyrbDa7bfv2TS9uTqVSxR1J57Jln/zEx2RZZlKAM8jHAQAAAAAmEw6Hv/+DeycmJ4s+krbWlttuvaW2tpZJmadYLPbS5pff3LEjmzU6jrik+eQdF+00Y9HiKfVrm26PJrWij0TTtGuvufrKKy6nC//8nTzZ+8tnnh0t9i09i8XS3tb2qd/5BHMHnIN8HAAAAABgPqFQ6J577xufmCj+79WSdOkl667fcJ3T6WReLiCbze7YueulzZuj0ViRZkr/o+uer/HMmq50zx9c8+qxbnHGU1Hhv+Wmm1asoN3Ku5iann7uuecPHjoswmDa2lo/9clPqKrKvADnrg7k4wAAAAAAMwqHw//zg3snBdhFbrFY7Hb7NVe/9/L1lxE/vZ2u60eOHN304ktF30LbVTv8qctfM1f1ZmPOr2+6NZ0VriFGa0vLDTdsaGps5Ax/u0gk8uprr7+5Y0c6nRFhPMs6Oj75iY+xcxw4L/JxAAAAAIAppdPpXz77/L59++JxUZpKu92ua66++tJL1pFDnXH06LEXN28eGhoWZDyfvfLltuoxExXwsd3r9/Y3Czu8zmUd12+4rqGhgVN9TiwWe/2NLdu2b08mU4IMyePxXnfd+y675GJmBzgv8nEAAAAAgClt3b6jv38gk8mcPHkiFouJMzCPx3PtNe+9+D3vKee95LquHzt+/JVXXjvd3y/UwBr801+4ZpMkmSMMGZ6t+NbLN4o/1uXLu6+9+r1Lliwp5ytSNBrdtv3NLVu3JRIJcUbl9fqam5slSbp8/aVNjUtZOIC3Ix8HAAAAAJjPyd6+nbv2zP05m8329vZGImGhRuh0Oi695JLL11/mdrvLamrS6fRb+/Zv2bp1bGxczBHeuW772qWnTFHMe7dce2LcNE9/bW5ueu+VV3Z1dUqSVFbn/OTk5Jat2/bs3ZtKpYUaWEVFoPHXDXBUVb3phg0uF49JAM5FPg4AAAAAMJlwOPz8ps3p9G+iKF3XT53qCwaDog1VluW1a1avX39ZQ319yc9LKBTatXvP9jd3hMNhkcfpd0T/9IZnFGtG8HoeHa3/0barTXcaVFVVXnH55WvXrLbZbKV9wuu6frK3d9u27YePHBVyIqrP6XtTVVl53XXXlNe9C2AeyMcBAAAAAGai6/qLm1+Zmpp++78PDPRPT0+LOez6+rpL1q0rydAwm80eP35i1+7dh48czWazphjzzSv3Xd1xWOiq6tJ/b75pLOQz6VmhqurqVSvXrbu4JB/gGQqFdu/Zu3v3nilRLzh1dXU1Nef55MGqlctXLO9mHQHORj4OAAAAADCTAz2HDh56x2RzeHh4fFzcpy+qqrpy5Yo1q1a1tbXKsmz2uRgeGTlwoGfvW/sE3Ll/YXY19Wc3/MKpJYUd4a5TbT/de0kJvGFraqovWrt21coVFRUVZv9ZksnkkSNH9x84cOToMWFvBUmStGTJkkCg8rz/rdVq3XDdNQHzzwVQyHcN+TgAAAAAwCwmp6Y2b341e8HfZCcmJoaHhwT/bdfhsK9YvnzVypWtrS2mC8pHR0cP9Bw80NMzMTFp3nPpirZjt6/eI+bYkhnl65tuC8XtpfTmXbKkYdXKlatWrvD7/eYaeSqVOnr02P4DB44eOyZah/FzWK3W5uZmj8d7ga/xuN033bihBO7PAYVCPg4AAAAAMIdsNvv8Cy8FQ6F3/crZ4Gz/6dOm6PVht9va29o6Ojo6l3V4vV5hx5lMJk+e7D167Nix48dnZmZL4HSSrdk/2fBswCViq/TNR1a+eHhlqb6Ra2qql3V0dC5b1tzcJHJKOz4xcezY8ePHj/f2nTr7aQfCUhSltbXN4XC861d2Luu4aO1q1hRgDvk4AAAAAMAc3tp/4MiRY/P84mg02tfXa4pU64zamprW1pbmpqampkYRsvJEItHfP3C6v//U6dOnTp3OZDIldkatahj42KVbRBtVOGH/2gu3JTNKyb+jNU2bO+HKbfB3AAAgAElEQVSbm5sa6usVpcg/sq7rk1NTp06d7u/vP3HypLnuA9nt9paWVk3T5vPFkiRdd+3VVVWVLCuAhXwcAAAAAGAK8+msco5UKtXb1xuPxcz48/p83qampiUNDUuWNNTV1trtRrTaSKfTExMTg0PDQ0ND/QMDIyOjJR8afO6aFxsrxOoS8/O31u3oay+3N7gsyw0N9U2NjQ319Q0N9YFAwGq1GnDccDg8PDwyNDw8ODh4ur8/EomasXoej7e5uTmninnc7ptuul42pMiA4MjHAQAAAACim39nlbd/4+nTp4NB0/cD8Xo91VVVlZWVgUCgMhDw+rw+r9fpdEqStLAXTCQSs8FgcDY4MzszOTk1OTk5PjExNTWVzZZXStAcmPi9q18SZzzjIe83Nt+c1aUyf8vLslxVVVldVRUIBCorK/0+39w5r6rqgq8hkUhkNhicnZ2dmpqenJycmJgcGx+PmfP+2dmqqqobGhoW8I10WQHmkI8DAAAAAER34OChgwcPL/jbR0aGx8bGSq8sVqvV7Xa5nC6b3eaw2202m6ZpiqJYrda5naS6ruu6nkqlUqlUIpFIJBLxeCIai4ZC4VQqxXk15xOXvbGiflCQwdy//b1HRhqYlHdit9vcLrfdYXfY7Ta7XVPVuXNekqS5e0XZbDabzSaTyWQqlUomY/F4LBaLRCKRSLT0EjBJkpYsWRoIBBb87TdseF9FhZ/zCmWOfBwAAAAAILRQKPT8Cy9l8nvY5uzsTH9/vyme2AmDVbpCf7zhOdla/HOjd6LmB2+8jxnBfKiq2tzc4nQ683mRCr//hhuuk6gmyhtthgAAAAAAQtu5e28m71zb5/N3dCyz2WzUE+eYjHhE6PetWyzP9KxlOjAfTqdr2bLOPMNxi8UyPTNz7Nhx6okyRz4OAAAAABBXb9+p8fGJgryU3W7v6Fjm8XipKs7x0pEVibRa3DHsG2gamqlgLvCuKisr29vbFUUpyKsd6DkUNX8TdiAf5OMAAAAAAEElU6l9+3sK+IKyLLe2ttbV1S34sZYoSdGk7ZWj3UUcQDprfeHQGiYCF2a1WpuampcsWVrAK1g6nd6zdx+1RVm/sygBAAAAAEBM+w/0JBKJgr9sTU1ta2tboXZfojRsOdE5G3MW6+jbTi6biTqZBVyA3W5ftqzT7y/84zQHB4dGR8eoMMoW+TgAAAAAQEQzM7O9J/sW6cXdbndnZ5fb7abOmJPOypsOrSrKoWNJ7eWjK5gCXEBFRWBRn6CwZ+8+XdepM8oT+TgAAAAAQES7976VXcy8RlGUtrZ2eq3gjL39LcOzfuOPu/noinhKpf44L1mWGxubGhsbrdZFDPGCodBRHtSJckU+DgAAAAAQzqnT/RMTkwYcqKamtr29XdM0ag7dYnm2Z63BB52KuLf3dlB8nJfT6Vy2rLOiwogHtx48dCQeT1BzlCHycQAAAACAWDLZ7P4DPYYdzul0LVJXX5jOifHaY2N1Rh7xhUOrM1nCGZxLkqSampr29g7D7t6lUqkDPQepPMoQl2AAAAAAgFiOHj0WjcaMPKIsy01NzU1NTbIsU/8y92zP2qxuUMudgenA/sFGao5zaJrW1tZeV1dvcPenvr5Ts7NB6o9yQz4OAAAAABBIIpE4fORYUQ7t91d0dna53R5moZyNBn17+luMOdYzPRdRcJwjEAh0dna5XC7jD53V9bf2HWAKUG7IxwEAAAAAAjnQcyiVShXr6KqqtrW1NTQsWdRH4UFwmw6tSmUW/ZMEB4eXnJqsoto4Q1GUlpbWpUsbi3j9GRkdHRkdYy5QVljvAQAAAACiCIXCvb19RR9GVVVVsfZvQojzMO5443jXoh4iq0vPH1xDqXGG3+/v6uryer1FHwlbyFFuyMcBAAAAAKI40HMwq+sijETTtPb2DjaSl61Xj3dHErbFe/0dfe0TYTr5wGKxWBRFaW5paWpqlmVFhPHMzs6ePt3PvKB8sMwDAAAAAIQwMzM7MDgk1JDmNpK73W5mp9wk08qLh1ct0osn0upLR1ZSZFgsloqKiq6ubp/XJ9SoDhw8rItxqxIwAPk4AAAAAEAI+w/0CJjIaJrW1tbe2NikKApzVFZ2nmobDy9Ks4tXjy3u5nSYgs1mm7u2yLIs2tjC4XBv7ynmCGWCfBwAAAAAUHwTE5PDI6PCDm9uj2cgEGCmykdWl57vKXyL8NmYY8uJTspbziRJqqmpFfyzKT2HDmezWSYL5YB8HAAAAABQfAd6Dgk+QlmWly5tbGtrt9nszFeZODTS0DdZXdjXfPHwqlRGprZly+VyLVvWWVdXJ0mSyOOMxWInTvYyXygH5OMAAAAAgCKbmJgcGx83xVDdbndnZ2d9fT3P7SwTzx5YW8CmPyNB/57TrVS1PKmq2tTU1N7eYbeb4x7b4SPH2EKOcsByDgAAAAAosp5Dh000WkmSqqtrurq6/X4/c1fyBmYC+webCvVqhU3bYaKLRlVVdVdXt99fYaJhx2Kxk719TB9KHvk4AAAAAKCYJienRkfHTDdsVVWbmprb29vtDgeTWNpeOLg6nS1AfnJ8rO74eC31LDcej6ezs7OhocGMHzo5fORoVueeDkoc+TgAAAAAoJjMtXn8HC6Xu3NZ59KlSxVFYSpL1XTUtb13WZ4vouvSs4vwtE+IzGaztba2tra2mfehBdForK/3FFOJ0kY+DgAAAAAompmZ2ZGRUbP/FIFAZXf38pqaGsEfuIcFe/nI8lhSy+cV9vS3jARpyFMuZFluaGjo7OzyeLxm/1kOHznKBnKUNvJxAAAAAEDRHD5ytER+u7Za6+rqTddfGPMUS2kvH12x4G9PZeRNh1ZRxnIgSVJ1dXV39/KqqurSuGEWjkQG+geYWZQw8nEAAAAAQHFEIpGBgcFS+ok0TWtqalq2rNPtdjO/JWZbb8d01LWw733jRFcwTp/60uf3V3R1ddfXN8iyXEo/1+Ejx5hclDDycQAAAABAcRw5erwkn/zmcDja2tpbW9scPLqzhGSy1ucPLqSBeCRhe+1YNwUsbW63Z9myzqamJk3TSu+nm56ZMeNTlIF5Ih8HAAAAABRBIpHo7Svlx755PJ5lyzqbm5vN+2g+nGP/YOPAdCDX73rpyMpEmse3liyXy9Xe3t7WVuL3w9hCjhJGPg4AAAAAKIITJ3szmUzJ/5g+n7+rq6uxsbEkd5WWoWd71ub09RNhz46+dupWkhwOR2trW3t7h8tV+v2URsfGZmeDTDpKEvk4AAAAAMBoWV0/caK3fH7eiopAV1f30qVLScnNrm+y+tBIw/y//rmDa7K6RN1KjMPhaGlpWbas0+PxlM9PffT4caYeJYl8HAAAAABgtP7TA7F4vKx+ZEmSAoHKrq7uxsZGm83GOWBez/WsnWfk3TdZfWh4CRUrJU6ns6WlddmyTq/XV24/++nTA4lkknMApYd8HAAAAABgtLLdhyhJ0txe8sbGJrudvuSmNM+WKXruzVggMpfL1dra1tGxzOv1lmcFMplMWX3uB+WDfBwAAAAAYKiJicnp6ZkyL0JFRUVnZ1dLS6vT6eSUMJ35PHLzwIIe5gkBeb3e9vaO9vaOsuqmcl4nTpzUdZ1TAiWGfBwAAAAAYKjjJ05ShDler7ejY1l7e4fH46UaJhJJ2F471n2BL8hkrc8fXEOhTE2SpDP3sVwuFwWxWCyxeHxgcIg6oMSQjwMAAAAAjJNIJAaJV36by+VqbW3t7OysqAhIEs9yNIc3TnQF4453+m+39XZMR0lUzUqW5erq6u7u5fRBejtarKD0kI8DAAAAAIzT23sqk81Sh7ez2x2NjY3Ll6+oqamVZYWCCC6VkTcdWnXe/yqW0l4+uoISmZGmafX1DcuXr6ivb1BVlYK83dj4eDAUog4oJeTjAAAAAADjnOhl7+GFKIpSV1e3fPnyJUuWsnFVcHv6W0aDvrf/+ytHl8eSGvUxF5fL1dTU3N29vLq62molLrvgZfwkl3GUFN7wAAAAAACDDI+MRiJR6vDuv6tbrZWVlZ2dXW1t7T6fj6YrYtJ16dmetef843TUtfXkMopjovdaIBBYtqyzvb3D7/dTkPk41Xc6k8lQB5QMPrEFAAAAADBIb28fRciJ2+12u92pVHJycnJqaiqdTlMToRwbqzsxXttePXrmX144tDqTZTOiCWiaVllZFQgEZFmmGjlJplIDA0PNzY2UAqWBSzYAAAAAwAiJRGJoeIQ6LICqanV19cuXr2hqana73RREKM/0rNX1X23wH5wJ7BtooiYikyTJ5/O1trbNtVIhHF+Yk319FAElg/3jAAAAAAAj9J3qz/JkzjxIkuT3+/1+fyKRmJqanJ6eZju5CEZm/Xv7m9/T1GexWN7ebgXi0DQtEAgEApWKQhqWr4mJyXA44na7KAVKAFcEAAAAAIARetlvWCA2m62+vqGurj4YDE5PT4VCIV3XKUsRbTq8etWS/hPjtb0T1VRDNFar1efzVVQE+OxFAem63tvXt3rVSkqBEkA+DgAAAABYdJOTU8FgiDoU0FybCJ/Pl06np6enp6en4vE4ZSmK2Zjj9eNddFYRjdPpCgQq/P4Kq5X2woXXd+r0qlUreXYwSmE95SYzAAAAAGCx7dq998TJXuqwqGKx2MzM9MzMTCqVohoGkywW4hVB2Gw2v99fURHQNI1qLKprrr6qrraGOsDs2D8OAAAAAFhcWV3vHxikDovN4XA4HI76+oZwODQ9PTM7O0PDd8MQjhedoig+n7+iosLpdFINY5w63U8+jlK4elACAAAAAMCiGh4eSSaT1MEwbrfH7fYsXbo0GAzOzMyEQkGCcpQqWVZ8Pp/f73O7PVTDYIODQ5mLL5JlmVLA1MjHAQAAAACL69TpfopgvDMNyrPZbDA4OzMzEw6HCcpRGmRZ9nq9fr/f7fZIEk2wiyOdTg8MDjU3NVIKmBr5OAAAAABgEaVSqeHhEepQRFar1e+v8PsrstlsKBScnZ0NhUKZTIbKwHQURfH5fF6vz+12E4uL4NTpfvJxmP7CQgkAAAAAAItncHCYKFYQVqvV5/P7fH5d18Ph0OxsMBicTafTVAaC0zTN6/X5fD6Xy0U1hDI2Np5MJnkUKkyNfBwAAAAAsIj6BwYogmgkSfJ4vB6P12JZGo1Gg8FgMBSMx2JUBkKdpU6n0+v1er0+m81GQcSUzWYHBoba2looBcyLfBwAAAAAsFiSqdTo2Dh1EJnT6XQ6nXV1dclkMhQKhUJB2pSjiBRFcbvdHo/X6/XIMrGVCfQPDJCPw9yXHUoAAAAAAFgkgwNDJK1moWlaZWVlZWWlruuRSGQuK4/H41QGi02SJIfD6fF4PB6P0+mkIOYyPj6RSCTY4w/zIh8HAAAAACwWmquYkSRJbrfb7XbX19enUqnwr4RSqRTFQQHZbDa32+P2uN0utyzLFMSksro+MDjU3tZKKWBS5OMAAAAAgEWRTCbHxieog6mpqlpRUVFRUWGxWBKJxFxSHomEeaonFkbTNJdr7v6LW1VVClIaBgYGycdhXuTjAAAAAIBFMTQ8QnOVUmKz2Ww2W2VlpcViSSQSkUg4HI5EImH2leNdzxyXy+12u1wuMvHSND4xmUylNCYX5kQ+DgAAAABYFINDwxShVM1l5YFApcViSSaT0WgkEolGo5F4PK7rOvUpc5IkOZ1Op9M193+KQvpU4rLZ7NDQcEtzE6WAGXGFAgAAAAAUXiaTGR0ZpQ7lQNM0TdP8/gqLxZLNZqPRSPTXaMNSVqeB0+l0OJxzJEmiJmVlkHwcpkU+DgAAAAAovJHRsXQmQx3KjdVqdbs9brdn7q+pVCoajcZi0Wg0GovFMpwSJURVVYfDMReIOxwONomXudHRsUwmw3NWYUZcvAAAAAAAhTdEcxVYLKqq+nw+n88399dUKhmNxeKxX6FxublomuZwOB0Ou8NBII5zpdPp0dGxhoZ6SgHT4VoGAAAAACi8YZqr4G1UVfOpms/7q7g8k0nHYvF4PJ5IxBOJRDwepx+LSJOl2u12m81ut9vsdofdbrdarZQFFzA0MkI+DjMiHwcAAAAAFNjU9HQ8HqcOuDBZVtxut9vtPvMvqVQqmUym02lFkUOhUCgYjHEiLb65x2l6vV673Z7NZhVFtdlsbA9HroaHuS0KU+JiBwAAAAAoMFISLIyqqqqqWiyW7q7OuQc8ptPpcDgcCofDoVA4EgmHw+FwOBaL6bpOuRbAarU6nU632+1x/5a5veHBYGhwaIgqYWFisdjM7Kz/1/2UALMgHwcAAAAAFNjw8AhFwILJsjwXjlssFkVR/H6/3+8/+wt0XY9EIpFoNBKJROdEItFYLBaL0aFljqqqc4/NdDmdTpfL5XLN/cFht5+p7duxZxx5X/xHycdhOlz4AAAAAACFlEgkpmdmqAMW7F1TWkmSzmnMckYqlYpGo9FYLBaNxhOJeDyemGtwHo/H4/FUKlUaG88lSbLZbDabzWG32+x2u81ms9l+9dxMh8PpdC4s6VZVYiLkZXh4ZHl3J3WAyRYdSgAAAAAAKKCR0TF6XyAf+aS0qqr6fD7fO+xg1XU9mUwmEonE3P9L/ko6lUqlUslUKp1KpdJz/5FOp9OZTMaYk1mSJEVRFFlWVFVRFFVVNVVVVVVR1bk/a5pm+zVN0zRNW4xhsH8ceZqamkqlUnNdkgCz4MIHAAAAACik0dExioB8KMpihWtntl3P/1symUwmk0lnMpl0Ons++lyCrutzf5j7myRJksUiSZJFkqy//k/r28iKoiqKLMtz7b+LTpIkWZYzmQwnIRYmq+tjY+NLljRQCphp0aEEAAAAAIACIh9HnlSRdjHLsizLslY+xVcV8nHkY2RsjHwc5mKlBAAAAACAQpkNBmPxOHVAPhS6YBex+AqdMZCX0dFxigBzIR8HAAAAABQMm8eRP5WItojF5+YE8hMOhyPRKHWAiZCPAwAAAAAKZnSMnYPIFxFtUYvPzQnkvRBwoxSmQj4OAAAAACgM3WKZmJikDsgTEW0xi8/mfeRtfHyCIsBEyMcBAAAAAIUxMz2TSqWoA/KhyLIkSdShWNi8j/yNkY/DVMjHAQAAAACFQSaC/ClsHi8qNu8jf7FYLByJUAeYBfk4AAAAAKAwxsdpPo58kc8Wl6Io7N9HAZaDMW6XwjTIxwEAAAAAhTFO83Hkjf4eRacoTAHyNTZBPg7TIB8HAAAAABTAzOwszceRP43940wBzG+CfBzmQT4OAAAAACiAyYkpioD8qapGEYo8BRr5OPIViUTj8Th1gCmQjwMAAAAACmBikuYqKAD6jzMFKJVFgZumMAfycQAAAABAAZCPoyDoPy7AFJCPoxCLAk+kgEmQjwMAAAAA8hWPxyORKHVAnhRZtlpJKoqM/uMoCG6awixYdQAAAAAA+eJz9CgIOl8LMQvk4yiEmZnZbDZLHSA+8nEAAAAAQL6mpqYpAvLHwzlFoCgKu/iRv2w2Oz0zQx0gPq53AAAAAIB8TU2Tj6MANPaPi4Et5CjM0sCtU5gB+TgAAAAAIF/T02wSRAFo7B8XZCK4UYFCmGJpgBmQjwMAAAAA8hIKhVKpFHVA/ohlRZkIblSgENg/DlMgHwcAAAAA5GWSBAQFomrEsoJMBDcqUADhcJi7pxAf+TgAAAAAIC88gQ0FYbVaFVmmDiJg/zgKQtf16ZlZ6gDRVx9KAAAAAADIxwzxBwqB5irMBUpxgeAGKkRHPg4AAAAAyAv5OApCo7mKMFRVlSSJOoAFAuWAfBwAAAAAsHCRSJT2sigI8nGmA6WHfBziIx8HAAAAACwcn51HoRDIMh0oPcFQKJvNUgeIjHwcAAAAALBw07PsDURhEMgKNh20IEcBZLPZYDBEHSAy8nEAAAAAwMIFZ4MUAQVhIx9nOlCKZlkmIDbycQAAAADAws0GCT5QAIosW61kFAJhOz9YJlAmWHsAAAAAAAuUzWYj4Qh1QP40G2msYDNCPo4CCZKPQ2zk4wAAAACABQqGQlldpw7In02zUQShyLKsKAp1QP7YPw7BkY8DAAAAABaIrrIoFPaPizgpbCFHIUSjsXQmQx0gLPJxAAAAAMACBYMhioCC4GmQIk4KNy1QCLqu02IFIiMfBwAAAAAsUCgcpggoCM1GfxXhcNMCBVssQiwWEBf5OAAAAABggYg8UBBWq1Wl1bV4NJrCo1CLBTdTIfIaRAkAAAAAAAsTJvJAIdDHg3lBiS8W3EyFwMjHAQAAAAALEY1GMzxyDYVgY5+ykBRFkWWZOiB/wRAPq4C4yMcBAAAAAAtBcxUUio3m4+JODVvIUQDhcIQiQFjk4wAAAACAhSDvQKEQwgo8Ndy6QAGk0+l4PE4dICbycQAAAADAQoQj5OMoDEJYcaeG1jcokEgkShEgJvJxAAAAAMBCRMjHUQiyLCuKQh3ExK0LFAq3VCEs8nEAAAAAwEIQdqAgSGDFnh1a36AwuKUKYZGPAwAAAAAWgg/LoyDIx0XG7n4UCrdUISzycQAAAABAzpKpVCqVog7In518XPAJsjNBKABuqUJY5OMAAAAAgJxFSTpQIDbiV7HZbXaKAFYNlDDycQAAAABAzqKxGEVA/iRJYv+44GiAg4KIxeMUAWIiHwcAAAAA5CwWJR9HAaiqKkkSdRAZ/VVQENlsNk5EDiGRjwMAAAAAchaN8Ul5FADZq/g0TbNaiY9QiIWDG6sQEhc4AAAAAEDOiDlQEPS2NgWbTaMIKMDCQWMuCIl8HAAAAACQM2IOFAT7x00yTdzGQAHQmAtiIh8HAAAAAOSMNrIoCIJXc0wT2/xRCDyiE2IiHwcAAAAA5CweT1AE5ElVVVmWqYP4uI2BAi0c5OMQEfk4AAAAACA3mUwmlUpRB+SJ5ipmYbNpkiRRB+SJG6sQE/k4AAAAACA3ZBwoCLp2mIUkSTYbNzOQ/9rB/nGIiHwcAAAAAJAbMg4UBF07TDVZ5ONg7UBpIh8HAAAAAOQmnmD/OArA4SAfN89k2R0UAXlKJJM6VYB4yMcBAAAAALlJkI8jbzyc01zY7I/86bqeTCapA0RDPg4AAAAAyA0BB/LnIG81FbvdZrUSIiHv5SPB8gHhcGkDAAAAAOQmQcCBvNlprmI2PKIT+eP2KgREPg4AAAAAyA0BB/KXz/7xdDpd9PFns1ld10t7zAWcMmAO7bkgIPJxAAAAAEBuEuTjyI8kSfn0s85ms0VP2cKRiCRJpT3mc7DlHywfKEnk4wAAAACA3LB/HHnSNC2fZtaapgWDoUwmW6zxT0xOOh0O043ZkeOYz5HntwMWiyWZTFEEiIZ8HAAAAACQm1SKgAN5ceS9E9nv9w0NDxdl8KFQWM/qiqKYaczhsJ7V1dzHfDZNVWVZ5uwFywdKDPk4AAAAACA3BBzIU/47kVVVtWna2Ni4wSNPJJOjY2OVlQGTjXl0gWMu+MSB5YMiQDTk4wAAAACA3KRSaYqAfDjsBYhZq6oqZ2Zng8GQYcPOZrMDA4OVgYoFN4cx45h/a+JoQY48l480+TiEQz4OAAAAAMhNOk0+joWTZavNpuX/OlartaqycnhkJG7Ucy8Hh4YsFktFRUVZjfls7B9Hnri9CgGRjwMAAAAAcpBKp3Vdpw5YMLu9YBlrRYVfluWBgcFMJrPYwx4fnwiHIzXV1SYcc1WhXtBht0uSxDmMBUvTXwXiIR8HAAAAAOQgze4/5MdZuD3IkiTVVFenUqm5XdKLJxgKTUxOOh0Oj8dtrjE7HA6Px1Oo17RarTabjXMYC5bi40cQD/k4AAAAACAHmQzpBvLidBayR4fX63E47JFIdHRsbJEGnEgkhodHLBZLTU216cZcW6Ax/2b6aLGCPKTTGYoA0ZCPAwAAAABykM6QbmDhJEkqeA/rmuoai8UyNTU9Oxss+ICz2ezA4FA2m/V6PAUcuRnHPIcW5MgHd1ghIPJxAAAAAEAOMuz+Qx7sNlvBG1g7nQ6P222xWEZGR+PxeGFffGBwKJlMSpJUXdCN2GYc85mRcxqDFQSlhHwcAAAAAJAD9o8jH47FSVdraqolSZrbN13A516OjY1HIhGLxVLh92uqypgtFouiKOoivCxYQYBiIR8HAAAAAOQgQ7qBPDgdzsV4WU3T/H6fxWJJpVIDg4V57mUwGJqcmrJYLLIsV1VVMubfTCJbyMEKghJCPg4AAAAAyAHpBvKxeNFqdVWV1Wq1WCzRaHRkNN/nXiYSieGRkbk/V1YGZFk22ZgDizVmy6Ld5EA50HU9q+vUAUIhHwcAAAAA5EDPZikCFsZmsy1eaCvLcmVlYO7P09PTs7OzC36pTCbTPzCYzWYtFouqqoGKCvONOVCxePPodJKPg0UEpYN8HAAAAACQg2yWrX9YoMXuy1EZCKiKMvfn4ZGFP/dycGgolUrN/bm6uqrgDxS9wJhjZhizpqnKr8cM5L6IkI9DLOTjAAAAAIAcZHWiDSzQYvflkCSpurpq7s+6rg8MDC7gYYCjY2ORSHTuz3a73ef1GjnmwQWOedzIMVvYQo58FhHycQiGfBwAAAAAkAOiDSyYAc919Pl8dptt7s+pdHpwYDCnb58NBqemps/8tbam2oCyFGLMUwaPmUd0YuGLCP3HIRjycQAAAABADsjHsTCaphnTlKPmrIA4GouNjIzO8xvj8cTZX+x2uw3bJV24MbuMGbOL/eNgEUGpIB8HAAAAAOSCnX9YEJfLadSBXC6X68xfp2dmZmbe/bmXmUxmYHDwTHInSVJNdbWBxSnUmGuMGbBhdztQiosIqwjEQj4OAAAAAMgBwQYWxsgdx7U11Wc/oHJkdDQWe5fnXg4M/ub5lhaLxefz2WyakfU535hjIo+ZLeRgEUFpIB8HAAAAAOSEcAMLYeQTHW02m/esZ1Tquj4wOJhOp9/p60dHx6LR6Jm/Wq3W6qpKg+tzvjEPiTxmp4t8HKwhKAXk4wAAAACAXBBtIHY6528AACAASURBVHd2u02WZSOPWFNdZbX+JvRIp9MDg0P6+Ro7zM4Gp6anz/6XykCgKM1DzDVm9o+DVQSlgXwcAAAAAJADgg0sgNPpMviIiqIEKirO/pdYLDYyOnbOl8Xj8eGRkXO/MVBRlCqZa8yqqqqqyrkNFhGYHfk4AAAAAABYXO5i9OKorDx3S/XMzMz0zMyZv8493/KcDdrVVb+1iZsxX3BaXZzbAMyOfBwAAAAAkIOzniAIzPOckZzF6MVhtVqrKs9tyT06Ohb99XMvBwaHUqnfavBts9n8fl8Ra2WuMbtoQY4FXBAsrCIQC/k4AAAAACAHEgE5cuR0OIp12lRU+DVNO/tfdF0fHBxKp9Mjo6NnP99yTk11ddHLZaIxO50uLgjIeRGxcs5ALOTjAAAAAIBcfo2U+EUSuXEVtQvH2+PjdDrd13dqenrm3HE6nW63EA1DamrmO2ZnUccsy1a73cYZjhwXEfJxCHZOUgIAAAAAwPyxXRS5Km4+7vG4nQ7HOf+YSqff/pU1NTWCVMzjnu+Ya4s9ZhctyJHzIkIaCbFwRgIAAAAAcsBH45ETRZaLvsW4pvbdQ2Sf1yvUVmizjJl8HDkvIqwhEAz5OAAAAAAgB+wfR05cAnQscdjtXq/nwmd1tQCdx3Mfc1XRx+l0OGRZ5jzH/FmtpJEQ7JykBAAAAACA+SMLQ07cYuwvrqmuvsCtnUBFhaoqopVuHmNWRRiny+nkPMf8kY9DuHOSEgAAAAAA5k8m2sC8SZIkSP8NVVUrKvznP6VluaqqUsDqmWXMgjzUFKZZRLjJCsHwP2sAAAAAADkg2sD82e12cU6YqsrK8w6mqqpS2A2tphgzLciRwwrCHVaIh5MSAAAAAJDLr5Hk45g3t0jJqSzLlZWBc/5R07QKv1/YAr7DmFWhxqwoit1u52wHKwjMelpSAgAAAADA/CmkG5g3t9st1Hje3rO7urpK8EfOnm/M1aKNmRYrmCc+gQQBkY8DAAAAAHL5NVLmF0nMi6IodrtNqCFJklRTXXXmrw6Hw+vxCF5GU4xZtBshEBb5OET8HzaUAAAAAAAwf6qiUATMh0fIzNTr9Z5pBlJTU22KSoo/ZofdrnBlwDxwnkBA5OMAAAAAgByQbmCehN1TXFtTbbFYPB6P0+EwSzF/PWa3sGOmxQrmgzusEBD5OAAAAAAgB8pvt0IGzstqtbpcTjHH5nQ6PR53TXW1ieop/phpsYL5rSDk4xDvtKQEAAAAAID5k61Wq9WazWYpBS7A5XSK/NzLJQ0Ngj+W03RjdrtcXBnwrtg/DgGxfxwAAAAAkBtarOBdeTxC7yY2XTgu/pglSXI5nZz5YPmA6ZCPAwAAAABywwZAXJgkSXTbKEOC3xSBEMsHHbogHvJxAAAAAEBuNE2jCLgAh8MhyzJ1KDdut9uMG/Nh7PJBPg7hkI8DAAAAAHJDPo4LYx9xeZJl2eFwUAewfMBcyMcBAAAAALlhAyAuzENzlbKdem6N4F2WD/JxCId8HAAAAACQGwIOXIDdbqfFcNnyeDwUARdaPrg4QDzk4wAAAACA3LB/HBfgJSEtY6qi0GIFF1w+uL0K4ZCPAwAAAAByo2k2ioB34vWSj5f3CcANElxg+bCRj0M45OMAAAAAgNzY7eTjeKdzg+Yq5Y4W5LjQJcLG8gHhkI8DAAAAAHJjI+DAOyAbhaqqDrudOuDtZFlWFIU6QDTk4wAAAACA3LB/HO/E5/VSBHjosQPWDpgH+TgAAAAAIDd8QB7nPzForgKLxWKxeLlNgvPhs0cQE/k4AAAAACA3NptNkiTqgHOweRxzVEVxOhzUAeew03gHQiIfBwAAAADkRpIkTdOoA87hpasGfnMycLME56IxPcREPg4AAAAAyBmbQ3HuKeF08OQ9nOH1eviUCc7hcJCPQ0Tk4wAAAACAnBFz4BzsF8bZZFl2Op3UAb+9cHBjFSIiHwcAAAAA5IyYA2eTJMnrobkKfovPxy0TsHDABMjHAQAAAAA5o78KzuZ2u2RZpg44m8fttlrJnXD2wsEHjyAirlMAAAAAgJyxDRBn89FcBW9jtVo9Hjd1AAsHRL9YUQIAAAAAQK6cTmIO/Iosy243MSjOgxsnOENVFFVVqQMERD4OAAAAAMiZy8WT9/ArHo9HkiTqgPNdKFyKolAHWCwWp8tFESAm8nEAAAAAQM6cTieRKOb4eQwj3hlP6cQcN3dVISrycQAAAABAziRJopMsLBaLpmnvdCZks1kRRpjJZEp7CgSvs9/n420Ci8XiJB+HqMjHAQAAAAALQYsVWC6Yflqt1lA4XNzhJZPJjBjx8eIRvM6apjkcdt4pcDlZMiDqVZQSAAAAAAAWgLADkiRduHuGLMuhUNGi22w2GwyGtDJ4JKDgdfaxhRwWi4v+4xAV+TgAAAAAYCHcbjdFKHMul/PCT190OhyhcCiRSBZleEPDw35/WSSzgtfZ5/VarQRQLBnk4xAUlycAAAAAwEJ4CDvKnt/nf9evqaqsHBgcNL5H9tj4uKZpF47vS4nIdbZarR4Pt9PKmiRJ3FKFsMjHAQAAAAAL4SbwKm+Koswn9NQ0zeVyDg4OGTm2YCg0OzNbVVlZPtMheJ3ncysFJczhsMt8hgCi4tQEAAAAACyEh82A5e3CncfPVl1VFY3FxsbHjRlYIpEYHh6pqqost54eItfZ6XRomsa7hvUCEBD5OAAAAABgIRRFsdvt1KFszX9HsCzLlZWBycmpYCi02KPKZDL9A4OKolRUVJTbjAhe5zLpBY/z4vNGEBn5OAAAAABggdgSWLZcTqemqfP/+spAQFWU4eGRRCKxqAMbHBpOpVI11VXlOS8i19nv80mSxHuHxQIQDfk4AAAAAGCBvF4PRShPFRW5tZOWJKm6uiqbzfYPDGYymUUa1djYeCQScTgcHk+Znpki11mWZa+HK0bZLhZeigBhkY8DAAAAABaIfLw8KYqygADa5/PZbbZUKjU4NLwYowoGg5NTUxaLpbamupxnR+Q6+yt4SieLBSAc8nEAAAAAwAKxJbA8LbiRdE1NtcViiUQiY2MFfoZkPJ4YHhm1WCxej8fhcJT5BAlbZ6fDYbPZeAeVG1VRnGX/roTIyMcBAAAAAAvkY0tg+ZEkqcK/wF3ALpfL5XJZLJbJqanZ4P/P3n0HtlGf/wO/qb2nbVnezoTskBSSEFZCy8pir/bbQVugzNIWKJRvofyA0vbbQoEOdoGWxAlZZJOEJGSRhOAMktiJh2zLjm3JQ8O60/3+UDGKHTu2dJJO0vv1V6TIp9Pz+egkPfe55+kQa5d4nq93ucLhMEmS1uxePC79OBuxhDz74EwqSBzy4wAAAAAAABAjhUIhk8kQh6yi0WgYhon5z+02a6RJY1OTOxAQp4dkvashFAoRBGE0GGQsizGScpz1Oh1NIxmVXVBcBSQOhyQAAAAAAACIHRIf2cZkNMbz53K5PLKYNBwO17tE6CHpdjf7fD6CIGiatljMGCCJx5miKL1ejwHKKnqsHwdpQ34cAAAAAAAAYhdzKWpIRwq5XKWKt46wzWqhKIogiFAoVO9qiGdTXm9HW3t75N9ms4mm6Tj3LRwOSyHO8aezpRxno9EYWdsOWUKPjwmQNuTHAQAAAAAAIHYGLAXNJsb4Fo9HMAzTuwjd5/O53c2xbScQCDS53ZF/syxrEmPfKIrq7OpKbZCDPT08H87gOMtYNlIeHbLluIH8OEgb8uMAAAAAAAAQu5hbNULaoWlarxenToLZbOotYt7W3u71DruHJM/z9a6G3uXeVqtFrCXJNE13dqYsRR4Ohzs7OmUyNrPjbEKXzqyhVCrRpgIkDvlxAAAAAAAAiJ1Or6NQKiE7GA0GsXLQFEVZzN/UsG5yuwOBwLC20NsrkiAIhUIhYoFjlVLZ2dUZDPakJMgNjY0i1iySbJzVarVcLsd7KhugBhdIH/LjAAAAAAAAEDuaojRaDeKQ8UiSNIq65tdoNPSuKg2Hw/WuhqEX3W5yuyO9IiPsNqu4L9ZiNte7XMmvRd7c0iKTyXpXfGd2nE0mI95W2QA1uED6kB8HAAAAAACAuKDESjbQ6XTi5m0JgrBF5VuH3kPS6/W2t3t6b2o0GpVKJe6OyWQytVrliq+n5XB1dHZ6Pd7o5d6ZHWd9AmYUSPEDArV0QPKQHwcAAAAAAIC4iNIXESTOnIDVvlqNRqVS9t70+Xy9fSAH4g8EGpu+eQxJkjarNRGv12qx+Pz+5paW5IQ3GAw2NjZZLGaKorIkziRJ4tQaPiAApAD5cQAAAAAAAIgL6iRkvMRVi7bZbNE329s9Xq93oAdzPO+qdwmC0HuPXq+XyxPS+o+mabPZ1Nra1tHZmejw8jxfV+9iGMaYsExi/zh7JBBno9GQiPMBIB1yuTz63AyANOEwBAAAAAAAAHExGPRo0ZnZzCZTgrasVCh0Om30PY1Nbv8APSRd9a4Qx/XepCjKajEn9FWzDNPY2BQMBhMaXldDYygUStBC+IHi3CSBONM0rdfr8P7KYDh7CmkB+XEAAAAAAACIC03TOh2SXBlLoVCo1arEbd9mtZJR51cEQXDVu7h+PSSbmtw+vz/6HrPJlNAC1iRJWq2WcDhcV+8aek/L4Wpubunu7lYpldoE97mVZpzNJhOJs2uZy4Ti45AOkB8HAAAAAACAeBlNSIJkLLPZlNDtsyzbp4NfiONc9a7oezweb7vHE30PwzBJWJqq1+sVcnkoFHI1NCZi+96Ojta2NqJf/ZPsiTPLslqtFu+yTIXi45AWkB8HAAAAAACAeFlMZgQhI8lkMl3i05cWs5mm6eh7fH5/09f9If1+f/9+klaLJTmlq202K0EQ3d3dzc0i9+oMBIKR16jTapVKRTLep5KMc6JPwECqkCSJwYW0gPw4AAAAAAAAxMtsQRIkQ0fWlIyRjTTD7HNnu8fj8Xg5jqt3NUT3iiQIQi6XGwz65ERArVar1WqCIFrb2rwdHWJtluf5epcrHA6TJGm1WZPzWqQZZ4VcrtFo8F7LPBqNWiaTIQ4gfciPAwAAAAAAQLx0Wi3yIJmHZdmktU80GY0sy/a5s8ntrq2r56J6RUYktJVlf3bbfyt3NzW5AwFxenXWuxpCoRBBEEaDQdbvhWdbnC1mXICSgTCskC6QHwcAAAAAAAAR4Dr6DBzTJPZOJEnSZrX0uVMQhGCwbz5apVJpNOpkxkEul0c60IbD4XqXCL063e5mn89HEARN0xZLUnOI0oyzUpnYHrCADwWAQSA/DgAAAAAAACKwmJAKySgMwySthkmETqdTKM5dhtue+FaW/dms/y3DHQqF6l0N8WzK6+1oa2+P/NtsNvUpCJ61ccZa4wz8UMCYQppAfhwAAAAAAABEYLYgFZJZA5rExeO97OeqxK3X6RQKefKjwTCMyWiM/Nvn87ndzbFtJxAI9PbAZFm2d5uIs0qlUqmUeN9lDJlMptNpEQdIC8iPAwAAAAAAgAgsqVgJCwnCMIzRaEj+86pUqkFaNZIkae1XGyRpzGYTwzCRf7e1t3u9w+7VyfN8vashHA5HblqtluSfgZBynK0WC956GcOKM6aQPpAfBwAAAAAAADF+XlKUyWREHDJDShaPR/Q2w+zvrL0lkznDo+tFNLndgUBgWFvo7clJEIRCodDrdCkcYgnGWaVSqVSoQp4hUngqC2DYh3eEAAAAAAAAAESBhEhmSNXi8QiZTGbQn6XuefJbWfZnNBpkMlnk3+FwuN7VMPRenU1ud6QnZ8Q5K5xkZ5yx6Dhj2KxWBAHSBfLjAAAAAAAAIA4b8uMZwWxO2eLxCMvXzTDPuNNi7n9nCiZ5VF576L06vV5ve7un96ZGo5HCQmkJxhlLyDODTCZLcndfgHggPw4AAAAAAADiMJvNNIWfmemNZVmjwZDafWBo2mwyRd8jk6V+ryK0Gk10G0mfz9fbb3Mg/kCgsembx5AkKZGltdKMM06zZQALrgOAtIIvLgAAAAAAACAOmqJMZhPikNYsFnNqF49HRDfDJAjCarVKYa8ibDZb9M32do/X6x3owRzPu+pdgiD03qPX6+VymUReiwTjrFQqB+kdCmnBjuIqkFaQHwcAAAAAAADR5NhtCEL6GqgmdfKRJNlbzl6pVOq0WulESalQ6HRn7E9jk9s/QK9OV70rxHG9NymKklSJbWnGGUvI050dHwSQVpAfBwAAAAAAANEgLZLWrBYJ5SUNer1cLifOLPktEbYz11kLguCqd3H9enU2Nbl9fn/0PWbTGeu1EeezksvlOp0O78c0pVQq+5xAApA45McBAAAAAABANCajUSaTIQ7pqP+y6JSz2axarValVEotVizLGo1n1OkOcZyr3hV9j8fjbfd4ou9hGMZkMkpw6CUYZ5vVIp2KOjAsuIoI0g7y4wAAAAAAACAmuw2VZ9OSBJdpa9Tq3By7NMNlMZtpmo6+x+f3N33dh9Pv9/fv22m1WChJNrCVYJyl0CcWYvwIQH4c0g3y4wAAAAAAACAmJEfSkUajVqlUEtyxPjloSe2YuV832naPx+PxchxX72qI7slJEIRcLjcY9JKdABKMs8VilubpBBgESZI4RQppBwcaAAAAAAAAEFNuTg4KI6QXkiRtVqS0hs1kNLIs2+fOJre7tq6ei+rJGYEID9dZz0CAxBmNhkg5e4A0gvw4AAAAAAAAiEmpVOj16K2XTvR6HVJaMSBJ0mbt29FUEIRgMNjnTrVKpdGoEbHhMptM/c9AgJTl5eYgCJB2kB8HAAAAAAAAkSFFkkYoirJiaXOsdDqdQqE458NsNhQdigVJktZ+ZyBAynJzcPCHNPwcRAgAAAAAAABAXEiRpBGz2cRItcZ3WjhntWW9TqdQYHl+jPQ6nVKpQBzSgkKhMBrRVRXSD/LjAAAAAAAAIDKz2YR6HWmBZVmzCSWe46JSqTQazUD/S5IklufHyY7V92kiN8eOIEA6Qn4cAAAAAAAAxIdESVqw2axopho/+8BhNJmMLMsgRPFQKpV6HVoapIG8vFwEAdIR8uMAAAAAAAAgPocjD0GQOLVKpdNqEYf4yWQyg17f/36api1mM+ITP5vNSlFIYUkawzA5dqz0h7SEgwsAAAAAAACILyfHzjBYNitdJEnascZfPBarpX8C12IxI6srCoZhcKZB6sd8u41GJwNITzhMAwAAAAAAgPhoisJaQikzGgxymQxxEAtD030quctkMqMBvQpFYzIZZZixEoZrhiB9IT8OAAAAAAAACYF0iWQxDGO1WhAHcZnNpuhrJqxWC2q7i4gkSZxykyyKovJycxAHSNcJjBAAAAAAAABAIuTl5qC4hDTZbTYMjehIkuw966BUKlHbXXRqtVqnQ1SlyGa1sCyLOECawschAAAAAAAAJATLsnas95QetVqFJGOCGPR6uVxOEITdZkU0EgGndqTJmZ+PIED6wjEFAAAAAAAAEqUASROJIUkyx462nAlks1m1Wq1SqUQoEgGlgSSIoihHPqppQTrPYYQAAAAAAAAAEsThyKVpGnGQDovZjCaHCaVRq3NzcAYigUxGo0KhQBykw26zylBcBdIZ8uMAAAAAAACQKAzD5CBXKBlyucxsNiEOiYZzQomWm5OD3qfS4XTiOiFIb8iPAwAAAAAAQAIV5DsQBInIQVYRMoJCITcZjYiDFNA0ne9AcRVIb8iPAwAAAAAAQALl5eWyDIM4pJzRYFChKDZkCqvVwqKmhwTk5uYwOMJDmkN+HAAAAAAAABKIpul8LCFPNZZlbTYr4gAZgyTJvNwcxCHligqcCAKkO+THAQAAAAAAILEKC5FASbHcHDtFIQMAGUWlUhkNBsQhheRyeS7OUkD6w6cjAAAAAAAAJJbNalWpVIhDqhj0erVajThABh5bbFZUWUmhAmc+WhpABkB+HAAAAAAAABKuENfgpwjLMna7DXGAjERRVG4O1i+n7sCOa4MgM44kCAEAAAAAAAAkWlFhAYKQErk5uaisAhlMrVYZjUbEIfl0Oq0JkYeMgM9IAAAAAAAASDitVmO1WBCHJDMajWo1KttAhrPbrDKZDHFIspLiIgQBMgPy4wAAAAAAAJAMSKYkmUwms9usiANkPJIk8/JyUQg7mWiKwlVBkDGQHwcAAAAAAIBkyHc6ZOiklywkSTqQMYSsoVQoLGYz4pA0eY48rNmHjIH8OAAAAAAAACQDTVEF6NKZLFaLRaFQIA6QPSwWs1KpRBySo6S4EEGAjIH8OAAAAAAAACRJSUkRgpAEKpXKbDalfDc4jkv5PoTDYUEQMnu4EedejrxcmkamK+E0arXdZkMcIGPgqAEAAAAAAABJYtDrUQMh0WiaduTlSmFPeJ4P9vSkdh+6urszvsgM4tyLZVm73Y6DQKKVlhYjCJBJkB8HAAAAAACA5ClDYiXB8nJzGIaRwp7I5XKv1xsOh1O1Ay0tp9UqVcaPOOIcTa/TGfR6HAcSh6bp4iIUV4GMwiAEAAAAAACQMbq6uv79/geJfpa5374yPz8f0Y5NvjNfcbAyEAggFIlgMhk1Go109segN7gaGp35juQ/tdfrpSiKpulsGHfEOVpOjt0fCASDQRwQEqHAmY/OnJBhkB8HAAAAAIDM0dnR8fe//S3RzzJ6zBjkx2NGkWRJceHhI18hFKJTKhQ2q1VSuySTsSzLtrSctlotyXxefyBwurWtpLgoS4YecY5GkqQjL+9UTU0K19RnsLLSEgQBMu2bCUIAAAAAAAAAyVRaUkxlekno5KNp2uHIk2CtbavF3O5p7+jsTNozcjzvqndZLGYym6YZ4hxNLpfl2NFAUnxmk8loNCAOkGGQHwcAAAAAAICkUiqVjlQUgshsebm5LMtKcMdomjabzI2NTUmrd+Gqd9EMo9fpsmoCIM596PV6gwGZXJGNKC9FECDzID8OAAAAAAAAyTZyRBmCICKL2azRqCW7eyaTkabpepeL5xNe76Kpye3z+6VWZwZxTokcu02hUOD4IBaVSpWPU5uQiZAfBwAAAAAAgGQzGY0WixlxEIVarU5y1enhIknSarH09IRcDQ0JfSKPx9vu8Wg0arValYUzAXHuH5B8R16W9GhNghFlpSRKY0EmQn4cAAAAAAAAUmDkiHIEIX4syzrycqW/n3q9TqFQdHd3Nze3JOgp/H5/k9tNkmR2Lh5PYpwDaRRnlmUdeXnI6ooSyZKSIsQBMhLy4wAAAAAAAJACjrxcjUaDOMT1k56inPmOdFkeG0mntra1dXSI30OS47h6V4MgCHq9Ti6XZ/OsSHycXekVZ7VaJfELLNJCSXERwzCIA2QkzGwAAIA0097eXl1dXV1V3dba6vP5/H5fIBBI+V4tuv6GcePHYXQAAGBYRo0o37tvP+IQs9ycnDTKBavVKo1G3dXV3djUJJfLRNxzQRDqXQ0cx1EUZbVkeyY0Os4yuUyBOBOE2WQKBIIdHR04aMSGoih05oQMhvw4AABAeqitqVn+0fKtW7fW1tRIcPdmzJyJ/DgAAAxXUVHBoSNH/P4AQhEDi9ms02nTa59tVmt3ty8cDtfVu4qLCsVa+d7kbvb7/QRBmExGLHGNjnM94vy1vNycUE+PP4CjTUzH6sICpVKJOECmQn0VAAAAqWtubn7i8cdvvP6Gd995R5rJcQAAgBh/kVLUyHJUIY+FVqtNx5IRcrlcr9cRBBEKidZDst3j8Xg8BEEwDGM2mTA3EOezIkkyP9/B4vRJDAdqkhw1EgdqyOhJjhAAAABI2a6dO2+7+ZZ1a9cJgoBoAABA5ikpLZbLZIjDsCgUirToyXlWVouFoiiCILq7fe7m5ji35vP73e7mr7dsjmwZEOezYhgmP9+BSTJcjnwHekVAZsNBAQAAQLo+3br14QcfQqlEAADIYAxNl6Os7XCwLOPMd5Akma4jzjAmkzHy77a2dm8c33M4jnO5GiJrCORymcFgiH/3OI5LeYjC4XD8CyMkHudUUSgUebm56fv2ST6SJMeMGok4QGZDfhwAAECiqqqqfv3Y46FQCKEAAIDMVl5WKmNZxGFIv+Epypmfn+4lts0mU+9LaGpyx9ZpXBCEeperN51ts1pF2Tee54M9PamNT1d3tygJXCnHOYW0Wk0GvIqkycvNidTqAcjkz1aEAAAAQIIEQXjqiScD6CAEAABZgGXZ8vIyxOGcSJLMd+TJ5fJ0fyEURVks5si/w+FwvauB5/nhbqSxyd3b2VWlUolV/0Eul3u93nA4nKrgtLScVqtUGR/n1DKZjCajEYeUoRxzxo4djThAxkN+HAAAQIrWrV177NgxxAEAALLEiBFlMlQhP5ecHLtarc6M12I0GHrrzodCoXrX8HpItre3e73e3pt2m5jLgQ16g6uhMSVh8Xq9FEXRNJ0NcU4tu92m1aKm9jk48nINej3iABkP+XEAAAApWrqkAkEAAIDswTLMSCwhH5TVasmwRJUtKtnq8/l62z+ek8/ndze39N7U63QKhULEHZPJWJZlW1pOJzkg/kDgdGtbb9HwjI9zyjny8lQiLdXPSFg8DtkD+XEAAADJ6ezsPHjwIOIAAABZpby8VI4l5AMwGY0WsznDXpRGo4nOTraduVR5ICGOczU09LavJEnSarWIvm9Wi7nd097R2Zm0aHA876p3WSxm0VtHSjnOqUWSpDPfkQEFixIk35Gn16HyOGQF5McBAAAk59ixYymsegkAAJASDMOMGjUScehPp9PZ7baMfGl96nU0nquHpCAI9fXf9IokCMJkNLIJaO5K07TZZG5sbAoGg8kJhaveRTNMgtKRko1zylEUVeDMZ9Ef+GyROW/sGMQBsmXCIwQAAABS425yIwgAAJCFystKUO6gD41G48jLzdRXp1AodFEZYUEQ6l2uQXpINjY1RSd2aZru7T8pOpPJSNN0vcvF8wlftdDU5Pb5/baEVfeWcpxTjmGYwgInwzA42kQrLipEfXbIHsiPEno7MgAAIABJREFUAwAASE4o1IMgAABANv5ApajzUO42ikqlynfkZfZrtFkt0RVFQiGuvt511ke2tbV7vR3R91jMZopKVFqDJEmrxdLTE3I1NCQ0Ah6Pt93j0WjU6kSeHJJsnKWAZdkCp1PEtqjpjmGYsWNGIQ6QRV8/EAIAAACpUSqxdA4AALJUUWGBPrO6UMbxfUDpzHeIXo1aaliWNRnP6Ejp8/ub3H2vpfP5fM0tLdH3yGSs0WhI6L7p9TqFQtHd3d3c3JKgp/D7/U1uN0mSNqstBXFukkScpUAulxU485EijygvL82wXqwAg0N+HAAAQHLyMn2lGAAAwCDGnT8WQVAqFAXO/MxetNvLYjH3yUu2t3s8nm96SIZCoXrXN70iI6xWaxJOHtisVoIgWtvaOjrE79XJcVzkden1OrlcloI4e6QSZylQKBTO/Gx50w1CLpePHjkCB2HIKsiPAwAASM6IESNkMhniAAAA2Sk3x56p7SiHSKFQOJ3O7MnTURRlMfctb93kdvv9AWKAYtlKpVKn1SZh39RqlUajJgiisUnkXp2CINS7GjiOoyjKarFkeZwlQqlUOJ3ZniIfO2YUqrFDtsGMB0g2nuePHDlSdeLEqZOnmpqa/D6fz+8fvHt49tBoNC/99WWcsQeQyWTTpk//dOtWhAIAALLTxPHnr1u/KXzmOtYsoVAoCpz5NJ1dX4mNRkNbe3soFOq9J5KuLS4qdDe3BAJ9E9OJa2XZn81q7e72hcPhunpXcVGhWCU4mtxuv99PEITJZExaOlLKcZYIlVLpzM+vq68Ph8PZd/gh9HpdaWkJPoMg2yA/DpA8B/bvX1pRse3Tbd3d3YjGQLZ9um3WxbMQB4BF1y9CfhwAALKWTqcrKSk+UVWdbS9cqVAUFDizcL0ISZI2q7VPJ0yO406equE4rs+DtVqNSqlM2r7J5XK9XufxeEOhkKuhocDpjH+bvYVNGIYxm0yIs6SoVMoCZ35tXTamyCeMH0cSAFkHizQBkqGxoeFn99z74x/dtXbNWiTHB1exZAmCAEAQxLTp06decAHiAAAAWeu8saOzrdqYUqnMzuR4hE6nVSr7tgTsn7SNZHiTvG9WiyUyLt3dPndzc5xb8/n9bnfz11s2J3nEpRxnqb0Zs61dpyMv127L3kGHbIb8OEDC7di+4/Zbb9u9axdCMRS7d+1yuVyIAwBBEI/9+nG9wYA4AABAdpLJZGPHjMqe16tSqQqyvvCxzXruuvMGgz75J04YhjGZjJF/t7W1ezs6Yt4Ux3Gur3tgyuUyQyq+7Ek2zpKiVCgKnFmUIqcpavy48/HRA9kJ+XGAxPp069ZHHn64q6sLoRiicDi8rGIp4gBAEEROTs7vX/y9RqNBKAAAIDuVlZUaDPpseKUajQbJcYIgVCqlVjvYN5+ktbLsz2wy9VYJb2pyx9ZBKlLsu3exdqoWaEs5zpKiUMiLCgvY7GhWOXJkeaQVLUAWQn4cIIHqamufePzX/S9Vg8GtWL4cQQOIOH/cuNf+8feCggKEAgAAshBJEJMnTiDJDC+Hq9PpnPmOjH+ZQ2SzWgcJhdlsStV6XoqiLBZz5N/hcLje1cDz/HA30tjk9vv/m1hXqVQpXAYh2ThLjUwmKywsyPil9Gq1evToURhuyFrIjwMk0P979tlIR3IYFo/Hs3HDBsQBIKK0tPTNd96+7fbb5XI5ogEAANnGbDYVFxVm8As0GY2OvFwMdC+ZTDbQRQNscltZ9mc0GORf50lDoVC9q2FYf97e3u71entvprbQs5TjLDUsyxYWFigUigx+jZMmjKMpZAghe2H2AyTKgQMHPt/7OeIQG3TpBIimUqnu+dm9K1atfOChB6dMnZrZ384BAAD6GHf+WHmGLt60Wi12uw1D3DcsXzfD7B+ulK+yt0UltX0+X2+bzXPy+fzu5pbem3qdLuXf6KQcZ6lhaLqwwKlWqzLy1TnycnNzczDKkNXvcYQAIEFWr1yJIMTsiwNfVFVVlZaWIhQAvXR6/Y033XTjTTcJgtDQ0HDq5MnTp0/7fX6f3xcMBGPYYGtr68oVKxBYAACQOJlMNm7ceXv27sukF0WSZG6OXa/XY3z7o2nabDa1tJyOvlMhl0shXBqNRqVS+Xy+yM229naF4tw7FuI4V8N/e3JGRt9qtSDO6YWiKGd+fmNjUzzdWSWIZZiJE8ZjfCHLIT8OkCi7d+1GEOJRsXjJz3/xCOIAcNZf1A6Hw+FwxLmd48eOIT8OAABpobiosLa2Lnr5bVqjadqRl5epa1FFYTaZPO2eUFRTIltKq5FEs9usJ0/V9N5sbHLL5fJBFoMLglBf74pusGQyGlmWRZzT8Ut4Xl4uK2NPn27NmBd13nljVColBheyHOqrACSEz+drampCHOKx5uOPUb0dAAAAACKmTJ7IMJmwwCtSyxjJ8cH1WWGtVqvVarVE9k2hUOh0ut6bgiDUu1yD9OpsbGoKBAK9N2ma7u3ziTinI6vFkpebkxklaMxmU3kZLtoGQH4cIDHa2toQhDh1d3ev+XgN4gAAAAAABEGo1erzxoxO91ehUiqLiwoztZy6uPR6vUIuJwiCJEm7xBY1286s0B0KcfX1rgF+GLZ7vWeU47BYzJSUGiFKOc5SnpwFznyaptP6VdAUNXXKJIwmAIH8OECCDLJ8AIauYvFiBAEAAAAAIkaMKDOZjOm7/3q9vqDAme45tWSK1PrQ63RyuVxSO8ayrMl4xlT0+f1Nbnefh/l8vuaWM4oCyWSs0WBAnDOASqUqLipM64iNHj1Kp9ViKAEI5McBEkSr0SAI8Tt+/Hjll18iDgAAAAAQccGUyemYXyZJ0m6zZUxNhqRRq9VajUYKrSz7s1jMfaZie7vH4/H23gyFQvWub3pyRlitVgnOASnHWcpYli0qLNCk529/o9EwetQIDCJABPLjAAlhMptVKpQUFMGSxUsQBAAAAACI0Om0548dk177TNO005mf1ivfU8jhyJNm3XmKoizmvmXEm9xuvz9ADFCUXKlUSna5rmTjLHEURTnzHVZLmp1aoGl62tQpOF0H8M17GSEASJDzx52PIMRv44YNHV4v4gAAAAAAESNGlKXRQleFQlFcVKjG0plYSTmFZzQaWJaNvieSFuc4rqGxKRAI9nm8TcLVvZEqjYfFYnbmO9Lo0pbzx47R6VBZBeAbyI8DJMqll12GIMSvp6dnxYoViAMAAAAA9Jo2dXKfvKQ0GQyGosKCtNhViAFJkjZr35Q3x3EnT9V0dHT0uV+r1aiUSgQtU2k0muKiQoVCIf1dtVotI0aUYcgAoiE/DpAoc6+80mQyIQ7xW1axFEEAAAAAgF4qlWrCeElfrElRVF5ebm6OHctyM5tOp1Uq+6ZEOY7rc89ZM+mQYSLlyA3S67/aZyenTZ2MwQLo+6mNEAAkiEKh+MnddyMO8aurq9u1axfiAAAAAAC9iosKC5z50tw3lUpZXFSo1+kwTNnAZrWd8zEGg14mkyFWGY8kydwce15ermSLuU+ZPBGd0gD6Q34cIIGuufaauVfORRziV4EunQAAAABwpimTJ2rUaqntVVlZybfnXpFjt2GAsoRKpdRqNIM8gKKotOvfCDEjSXJkedncKy6VYEvekuIiZ74DYwRwlgM1QgCQUL9+8smZs2YhDnHavm1bS0sL4gAAAAAAvRiGmT59KkVJ5VetXC6/6MLpkyaMp2na4chDcZXsYbNZBxlrs9mURp0bIR4URRU4861Wi1qtvuySi0eNHCGdg4BOp504YRzGCODsb16EACDR39qfe+H5//nB9/GVKB4cx320dBniAAAAAADRTEbj+WPHSGFP8nJzrpxzmSMvt/cei8VcVOjEr4BsIJPJDAb9Wf+LZRkzulJlzTQoLS3W6bSRmyRJjjt/7CUXz5TCZS40TX9r2gU4HAEMBPlxgMS/zSjqR3fd9e57/7r8iiskW4ZM+j5atoznecQBAAAAAKKNHFmel5uTwh1gWXbK5IkzLvqWXC7v818ajaastFjR737IPFaL5ayXMlgtFlxGkA00GvVZ3+wWi3nOnMtKiotSu3uTJozX69ERAWBAyI8DJElxScnTv3tm1ZqPn/jNk1ddffXoMWPU0quWKGUtLS2fbt2KOAAAAABAH9MumJKqFZo5dtvcKwZLfvVZUgqZiqZps7nvOnGFXK7X6xGcjGexmIuLCgdanc3Q9JTJE2fNvChVjTGLiwqLiwsxTACDwFJWgKTS6/Xfueqq71x1VeRmV1eX3+8PBALBYFAQhNTu2+OPPlZz6pRYWysqKvrRj+969Je/EnEPlyxeMvuSSzCLAAAAACAay7IXXjht46YtybzcUCaTjR93XnHRubNOFEUVFjibW043N7ek/Ds/JI7ZZPK0e0Ic13uPzWZFWDIbRVEOR65hCGdBcuy2K+dc9sWXldXVp5J5HDAaDJMnTcBIAQwO+XGAVNJoNJpBe50nTXVVtYjJcYIg5s2ff+lll40YOfLYV1+Jtc29e/bU1dU5nU7MHAAAABgwF2AyPf27ZxL9LCNHjUSoJcWg10+aOH7P3n3JeTpnvmPihPEKxTAKp9isFpVKWVfn4qLyp5BJSJK0Wi0NjU2Rm2q1GlcMJwFDdKrCR1mhPUwq/GRJgMxP2lPL5fLCgnz5kAsoMQwzeeKEwgLn3s8PdHR0JGEPZTLZhd+aJp0mxgASPpIAABDEsqUV4n4Mf+eq7xAEsXDRwmef+Z1YmxUEoWLJkvvuvx/jBQAAAANRKBSXX3EF4pCFiosK29raq6pPJvRZ1GrVpIkTcnPsMfytRq0uLyupqa33+XwYr4yk1+vb2toDwSBJknYsHk8whvDmcu/o+W0k8c05pyDpaKWvbqMvExJcT9ig1zsceRQ17OLyFrN5zhWXHj361ZGjxxJ6yQtJktMumKJWqzBVAM4JJ5EAgAgGg6tXrRZxg5dceqlOrycIYu6VV4q7QH71ylU9PT0YMgAAAADob9LE8VarJUEbp2l6zJhRV869IrbkeATDMKUlRRaLGT0bM1Wkpopep5OjL2siKYS6sp5HDPzm6OQ4QRBywZXHvVYW+rlCqE3QU1MUmZeX43Q6YkiO/3cLJDlm9Kgr51ye0N7C484fG8/BCiCrID8OAMSG9eu7urpE3OD8BfP/+61FoYgsJBeL1+vdsH49hgwAAAAA+iNJ8qJvTUtEUYvc3Jy5V1x23pjRtBiVCnJz7IUFToZJwfXcauGwnf+Pk/s/J/dnG79YIdRh2ogcYbVaq9Ek7jwNEATBEN6i0NOs0DrQAxThmrLQL/XhnaI/tVwuKykpNptMYkwV1YyLvjXjwukajfiHrKLCgpEjyjFVAIYI+XEAIJYuEbO4SmFR0YSJE3tvLli0SNzVMRWLl2DIAAAAAOCsZDLZjIums+KlnnU67awZF8686Fvi5rC0Wk15WUky61PrwrtH9Nxf0vOEjfuPgf/UwG+1cx+U9zxQwP2RIbowc0TkcOSl5ORHFkWYe22Q5HgEKfQUhP5gCm8U8XkNBn1ZaYlSoRBxm3l5uVfOuXzc+eexLCvWNs0m05TJEzFPAIYO+XGAbHf8+PHKykoRNzh//vzom0VFRZMmTxJx+5WVlcePHcPAAQAAAMBZ6XW6adOmUnEv0VDI5ZMmjp97xWU5ialRwDBMSXGh3WZNdK0VmvAVcH8oDD0vF+rPEi5+e0nPYyzhwcwRC4rnJJRGqNTxu4f22LAj9JohvD3+J6UoKj8/z5nvSESvS4qiRo0s/86VV5SWFMe/fZVKedGF09GTE2B4b0OEACDLLatYKuLWejtzRlu4aJG4+7wES8gBAAAAYGB5uTkTJoyL+c8Zhhk7ZvR3vjO3rLQk0blOm81aUlwkk8kStH2Z0FLa85ie3zHIY+SCqyD0PEmEMXNA+qzcsH7AhvO5l1XCiXieUaVSlpeVGA2GhL4uuVw+edKEuXMuy893xHzYkbHsrBkXKhSofQ8wPMiPA2S1YDC4ds0aETd4yaWXRDpzRrt49myLRcwCfGvXrOnu7sbwAQAAAMBAykpLYii/S9P0iPKyq749Z+yYUQxNJ2dXVSpleVmpyWgUfcsyoaUk9IR8CEXGVeFjFn45pg1IHEu0asJfDutPSKHHGfojTfhjeDqSJO12W2lJceLOYPWh1WgunH7BZZdeHMNlKzRFXfitaTqdDvMEYLiQHwfIauvWrBW3M+e8M4ur9P7MuHbedSI+i9/v/3j1agwfAAAAAAxi/LjznM78of42pqjSkuLvXDlnwvjz5fJkr76kKNLhyBW3aSdDdBWH/pcVWob4eBtfEVsOESBp9PxuYvgXOsgEdx73j+H+lVwuLy0ptqWi1arJaJw148JLZ88aeqNXkiSnTJlks1kxSQBi+RRGCACy2dKlYhZXKSwqmjjp7KXG582fT4u6AKdC1J6iAAAAAJCRpk2dfM4EE03TZWUl3/n2nMmTJiiVihTurU6nLS8v1em08W+KJISC0IsyoXEY2QHBZ+I3YM6AlGnCX8T2hwZ+izZ8cKhvH5I0m03lZSWpPSBYLOZLLp45++KZdpvtnA8+f+yYwgInZghAbJAfB8hex746dvjQIRE3OG/evIH+y2azzZg5Q8Tnqq6qOnDgAAYRAAAAAAb7xUtRMy/6ltF49sLBLMuOHFl+1bfnTpowXqVUSmGHGZouLHA6nQ6GiWtxiY1frB5mGQqCIAzhLZgzkDQkIWiESiu/3M7/xxRerxBc5/wTZRyVxPO4fwylyL5cJisuLszLzZFIn1Wb1XLxrIsuv3S2Iy93oF0aMaJs1KgRmFEAsX/4IgQAWWvZUjGXYMtksquuvmqQByxcdP2WzWJ+4V66ZMmECRMwjgAAAAAw2I9ehpk148JNmz/t7OzsvVOpUJSXlZaWFrMsK8F9Nuj1GrXG1dDY0dERw58rhWob92EMf6gIn2KJ1hBhxrSBRNOHP8vl3mKF09F3+qmSZvr6Dmrq2d/LhJcRPLH/YhUaTPy6VvrKgR5AkqTZZMzJsUskMx7NZDJedOH0zs7Or46dqKmt43m+97+KiwsnjDsfMwogHlg/DpCl/H7/2jVrRdzgWTtzRrtg2gVOp5gXfG3auMnj8WAoAQAAAGBwcrn84lkXqVRKgiBMJuO0C6ZcddWVo0aNkGZyPIJh6MKC/AJn/nArkpOE4OBei6FGc4Rm+KvOAYYrh/+gIPRin+Q4QRDKcHVh6Lmi0HMM0dn/r2RCc5zPa+OXUAQ3wFFCVlxcmCuZZeNnpdVqp0yeeNW3544dM1qhUBAEke/ImzJ5EmYUQLyfuQgBQHZat3Ztd3e3iBs8a2fOPhYsXPh/f/qTWM8YCoVWfLT89jvvwGgCAAAAwOBUSuXsWTOCPT1mkymNdluv12k06sYmt8fjFQRhKH9iDG9ShqtifkZluKqdmj3YA4RqfXinInyKIgIh0txNne+hLgwTCswxGCIzv87KLR7kAdrwnrKeR06xjwbIM9ZXsUJrnE/NCO1GflMrPSf6TpIkrVaLzWqRcmY8mkIhHztm1OjRIxsaGvPycklMKYC4Yf04QJZaKmp/y0E6c0a76pqrI2e5RXsVovYXBQAAAIAMptFo0is5HkHTdL4jr7ioQC6XDeEXfo+d+3c8T6cQ6gb6L5VwojT067KeR6xchTa8Tx0+bOA/dYT+OrLnHl14NyYYDIVMcOfyb57zYazQUhJ6QimcOuO9QIiwwMvCr4i+qVapystK7DZruiTHv3mzk2S+I48ikR4HEOMNhRAAZKGjR48ePXpUxA0O0pkzmk6nu+zyy0V83gaX67MdOzCgAAAAAJDZ1Gp1eVmpzWalqMHSYSZ+AyO0xfNErNDS/06SIOz8f0p7HlWFj/T/X0bwFIZ+bwpvxDDBOeXw75FCz1AeSQudxaH/lQvu3nsoIRj/DsiERk34IEEQNE078nJLSorkcjnGBSDLIT8OkI3EXTx+zs6c0RYuWiTua1myeAkGFAAAAAAyHkmSdpu1rKxUq9Gc/QEEb+GXx/ksLNHe5x6KCBVwL9i4/wxa0zzsCP1NLRzFMMFgvxyFZj3/2dAfTwsdhaFnaSLw9R2CKLthCm80Gg0jR5SZTEYMCgAQyI8DZCGfz7d+3ToRN3jOzpzRxowdM3r0aBGf/bMdO9xuN4YVAAAAALKBXCYrKiooLHDKZH2bi+rDu/o3PBwuUughCT4qZcAVhp7T8buG8Kd8fuiv5ADNDwEIgjCGtwy3c6xcqM/j/hb5tyBSCksv7M3PNdI0jREBgK8/7AAgy6z9eI3P5xNxg0PpzBltgahLyHmeX1aBKuQAAAAAkEV0Ou2I8jKb1RJdbsXErxUpTfBNFYt87iVN+MAQ/1AmNBjDmzE62UAhuHL494pDT5eEnijg/mjhVzOE99zzNqY69QZ+qyG8gyCIMClSL6twkPB+gkEEgKgPPgDIMuL2tCwoLBxKZ85oc+bO0Wq1Iu7D8uXLeZ7HyAIAAABA9iBJ0m63lZeV6XU6giBkQrM6fFjcRIGVX6bntw3rLy3cSgxNhk88gs/jXi/vecDKVWjCB9Thw3p+ey73+qjgXQ7uHwzROdAfMkSnInwqtifN5V6nCR9PiPcr0rsFQwkAfT/2ACBLHD50+NhXX4m4wXnz5w33T+Ry+VVXXy3iPrSePr35E5z/BwAAAICsI5OxBQX5JSVFVnqXWNWZI1UsVMKxHO79YX/VF+qVQvXQH08Os9oGpBZJ8EWhZ8386v5lUkiCM/Frynse1AiVZ/1bZbgq5inKCB479wFH6kV7JR3bMJoA0Av5cYDssmyp6J05Y8l0L1i4gCRJEfekYgm6dAIAAABAllKrVCZyjyibEggmTMgoIuQM/YUgYrlGUxf+fPAHMESHlV9WFnr0vJ5bzgveMLrnhwXc/6mEExhH6cvjXh+83g4jtBf3/NYU3tj/vxRCbTxPbeLXEYR4PyFD7YT/KwwoAEQgPw6QRbq7u9evWy/iBmdfMluvj+UcfkFh4eQpU0Tck32f76upqcEQAwAAAEA2CrUQ/iOibIkn1QRBWPklMqExti2ow5UD/RdJhG18xcien+Zw7yrDx0ihhyAIRmjX85+W9jyaw79LYiglTC0cNvHrhjKJHKFXTeENfe6VCe54np0kOBO/VrQS5ARBdH2OMQWACOTHAbLImo8/9vv9Im5w3vwFMf/twkULRdwTQRAqFmMJOQAAAABkpY5thCBOcRWONLNEq5VfHvMWlMLJs97PEp6S0K/t3HuUEDjb/4et3LI87jUMpmTlcO8PuUCK4Aj9TRfee8YEENri3AED/2mIzBXt9XQfxJgCQATy4wBZZOkSMYurFBQWTpo8KeY/n3XxxVarVcT9Wb1qVTAYxCgDAAAAQNbp2ivWlnpIaw73XmRld2wowccSrX3ulAuNpT2/UoXPUdHCxK83hdFYSIqUQrUqPKxrFMJO7k8Koe6biUHEu1SLJDhBpCL7BEGgvgoARB2gACA7VFZWnjghZlG/GDpzRqNpet78+SLuT2dn57q16zDQAAAAAJB1xKsUwZE6A/9pnBuRCS19bhaHnmLPvHMgOdxbNNGNIZUaI791uH9CCQEn9yeK4P57kwjEvxtxFmk5Q+AkgfawAEAQBEEwCEFC8Tzfevp0c0uL1+vt6uzs7u7u7uru6uoKBAIhLsSFQjzPh0Ihng8zDMMwNE3TDMuyDKvWqFUqlUqlUipVOr3OZDQaTSaz2cyyLKIKsVlWsVTErcXcmTPadfPnvfH66xzHibVXFUuWXHPtNRhriI3H42l2N7e2nvZ4vF6Pp6ury+f3+X3+np4gx/E8z1MUybIsw7ByuUwmk7Msq9aoDQaD0WQyGY2RfygUCkQSAAAAkvuzs5MI1Iq1MXm4Kf6kISO093ZSpAl/Ueh3rHB6iH9LC10WfpWbvgEDKynacCznYBThGhv/QRN9m1i7QQni1QsN9+zcXMFqiswWi81mU6lUGGWArIX8uGiamppqa2rr6+vq6+vr6+qbmppOt7S0t7cLgiDis2i1Wpvd5nDkOxyOnNwch8NRWFSUn59PkmhkAoPp7u7esF4SnTmjWSyWmbNmfbJpk1h7deTw4aNHjowaPRojDud8R1SdqDpx4njNqZr6+rq6uvqmxsaenp74t2wymfKdTqcz35Gfn5+fX1xSUlJSQtM0Yg4AAAAi6uzsrK2tra2pra+rk/UcvPNC0basEkQoOkFHrRR2hv4sjyqyMaQvVPz6Zvp6gcCPXKlgibaY+7VauRUeamaALBREKmAgkLJ46v9Ee+tvz+4//t8v6kql0mqz2e12Z4GzwFngLCwoKirKzc2lKNRdAMh8yI/HiOf548eOHT92/PjxY8e+Onb8+PHu7mRcAtbZ2dnZ2Vl1oir6ToVCUVRUVFpWWlJaOmbMmNFjxmABI/SxetXqQCAg4gbj6cwZbeGihSLmxwmCqFiy5NHHH8eIQ/+D9pHDhyu/rDx8+NChQ4cbXC5xT172amtra2trO/jFF733yOXyktLSUaNGjRg58rzzxpaPGIHhAAAAgOGqramprDx04sTxE8dPHD92rL29vfe/FswKESLlx8XKPPZuxMyv1Yb3DDtPIbSrw5Vd1PkYd4lQhqvj+Saey711kn0iTChF2RlSEO36Y5Pum18Efr+/tqamtqZmz+7d0d/ky8rLRo4aNXLkyJGjRpWXl2PhC8CwtLS0nKw+efJktdvtbnY3n25pOX36tD8QCAYCgUCA53mZTKZQKJRKpUqtttvtOTk5drs9z+EYMXJEUVFR0vYT+fFh8Pv9Xx788sCB/fv37T9y+LC42cZ4BAKBo0ePHj16NHKTpumi4qKxY8dOmDhxypQpNrsdYwdLKyTUmTPalKlTC4uKak6dEmvf1q1d97P779doNBh0EATh6JEju3bu2r179+FDh1J10A4Gg0cOHz5y+HDkpl6vnzR58uQpk6cPdGnsAAAgAElEQVRMnZrMz3sAAABIL6FQqPLLL/ft21f5ZeWhysqOjo6BHplrFq2GskAwJCHKylySIAgZcTqHfye2v9cKB7oI5MelQjHMKwD60IQPasNf8KRYv9FEm/B6tXDOb/KHKg8dqjz03zgoFOPGj580adKkyZPHnjcWuXKA/jo7Ow8ePFh58MsD+/cfP368q6vrnO+yYDDo9XoJgqiuOmM1sEajGTV69NixY6d/a/q48eMT+o5DfvzcqqqqdmzbvnPnZ18c+ELEQsmJw/N81YmqqhNVyz9aThCE0+mcMnXqtOnTpk2frlQqMaBZ6MuDB/scZeJ03bzrRNza/AXz//SHP4q1tUAgsHrVqhtuvBHjnrUCgcBnO3Zs+/TT7du2ezweqe2e1+v9ZNOmyGUTVqt15sWzZs++ZPKUyfh6DQAAAARBHD9+fOeOz3bu/Kzyy8pgMDiUP8kxi3ZVHCX4RNmOQNIEQeSF/kEJMS5QUIcPE/hyJBlDLx8/EBv/oZ8sE2t/OJ5gxJgeCvnw3juBQGD3rl27d+0iCEKhUFwwbdpFMy66aMYMi8WCSQLZLBwOV35Z+dmOHdu3bTt+/LhY12p3dXXt3bNn7549b735pkajmTZ92oyZsy659JJE1MxAfnxA+/ft27B+w7ZPP3W73Wn9Qurq6urq6pZWVLAsO3ny5ItmzJgxa2Zubm7SdiAYDMrlcsyoFBJ38bhMJrv6GjF7YF59zTWv/vUVEdf2Vixegvx4FgoGg9u3bdu4YcP2bdulc33P4FpaWioWL6lYvESv18+cNWv2JbO/deGFSJQnjSAIgUAgHA6n70sgSTKDe0kFg8G0WJcw2PdshsFXoIwZzbNSq9UYXBAFz/P79+3b/MnmrVu2NDc3D/fPjRpBcq+IUGuEQ9rw3pi3oBBqSUJACXKpfKIR8S46UYWPBuhi0T5WQuLkx+k4SosHAoGtW7Zs3bKFJMmRI0dePHv2nCvnOhwOzJY04vf7pfxbQKFQSPy3Ic/zO3fu3LBu/Y7t2yMLwBOnq6tr44aNGzdsfOG55y697LKrr71mwoQJoh7l4EyVlZUb12/YsH59S0tLhr20UCi0c+fOnTt3/uHFF88777w5c+dePucKo9Eo+hM1u91bNm/ZsWNHdVVVW1tbKBSSy+VGo7G0rHTq1AtmXjwLnxnJ1NnZuXHDRhE3ePFsETpzRtNoNHPmzolc7iCKU6dO7ft8n1gVYED6Dn5xcNXKlRs3bDjnpVuS5fV6V65YsXLFCqPR+O2rvnPtddeh9IroTp8+/dmOz746erSqqqq2tra7qysYDCaoDH0ykSSpVCq1Wq2zoKC0tLR8RPm06dOtVmt6vYpgMLhn9+5DlYeOHz9eXVXV0dHh9/t5ns+AiUfTtFKpNBgMJaWlpaWl551/3pSpUzM7aR4MBvfu2VP5ZWVVVVV1VZXH48mY0ezDZDKtXrsGR1eI04EDB9Z+vGbTpk3eOC5606rE+TgLhgg5K1LShNTkcO/G9QEnBFnhdA9pxSSRxMeZGBcWKISTYu2PWqTFo6J8ExQEIVLw9rVXXx09ZszcuXOvmDvHbDZj2khKW2vrzp27Ir8Fak6d6uzslP5vgd8+88wVc66Q5r7t+3zf2jVrNn/ySaLT4v35fL7Ib+fSstI77rzzijlzRGmiS2bAL0NRdHi9q1et/mjZspMnT2bPq6ZpesrUKddce+0ll14qylmplpaW1//xzxXLlw+yRIiiqJmzZt5z773OggJMvCT49wcf/PHFP4i4wZdffWXy5Mni7uTRo0e/e/sdIm7wsssvf+bZ32H0M1tXV9eqlSuXVSzNyOP2uPHjr5t33RVz5shkssQ9y/Fjx26/9Taxtva/T/92zty5Egzm1i1bP3j//f379mXPd54JEybcctutsy6+WPq7WltT8+4776xbuy5dLvsQITugUFx+xRW333lHYWFhhr206qrqd95+e9PGjUOsCJHukB+HeLjd7hUfLV+1cmVjY2P8W3v/SV9xrghLIAWBIEVaru1i73GEXor3qCJ7upschdkiBaWhx1Thr+LPQBCEaKdLG1rJvLgrC73wvnzJFlb0cDEMc9GMGQsWLpg2fTomT8rt2L7jvX/96/O9e9Put4AE8+MdXu/KlSuXVSytra2VyC458vNvu/32a6+7Ns6sJtaPEwcOHFj8nw+3bN4cCoWy7bXzPL9r565dO3eZzearr7lm3vx5uXl5MW/t061bn3ryN+dcvxkOh7ds3rJj+467773npptvxgxMtGUVS0XcWkFBgejJcYIgRo0aNWbs2MOHDom1wS2bN7e1tppw0j5D1dbUfPD++x+v/tjv92fqazz4xRcHv/ji5b+8dMONNy68fpFWq8W4x5Z9+M0TT+7fty8Lv9scOHBg4sSJv37yiTypXrPF8/xfX3r53x98kJFlNwYRCARWrlix5uOPb7r55p/c/dPMKKkUCoX+8uc/L/lwcUauEwcQ1/bt25d8uHjXzp0ivl9oSpztkKLVMiEN/Ob4t8IIXpRXkQxRRoIXSBkpiNIAljhaQ+WZ430TdSXmxwTHcVs2b96yeXOewzF//vzr5s/T6XSYQ8nX0tLyv795as/u3QiFCO+4I0c+eP+DTRs39vT0SGrHXPX1zz377Pv/+tc9P/vZrItnxf6Jk7VDKwjCJ5s2/evdd3s7EWez1tbWt9588523354xc+Ytt90aQxGfd956+68vvzz003GhUOhPf/hjQ0PDgw89hPgnzoEDB8RdWnvd/HkJ2tWFixaKmB/nOG75R8u/+z/fwxzIMF8ePPjWm2/t2L49rWtGD11bW9urr7zy9ltvXTdv3s233Gyz2zEHhq6ysvKh+x9I/hV/0rF///47brv99394ccLEiVLbt+7u7ofuf+DAgQNZOzocx737zjtHjxx54Q8vpnv79I6Ojgfuuw/fqAEGFwwGV65Y8e8P/l1bUyP6xnkxvhY1tZJi9fnkSKM6LMIxgSICmDkSIYiUOxIIhiR6RJr2ZGMrmRvfpHW3UQmNW4PL9fJLL73+z39ee911N996S05ODuZS0hw/duxn99zb3t6OUMTpsx07/vXuv/bu2SPlnaytrX3k4YcnTZ78wIMPlI8YEdMnTlb+IFmyePHC+Qse/eWv8FU+Wjgc3rply49/+KMffv8Hmz/5ZOh/uHrVqpdfeimGa1X+88G/333nHUQ+ccRdPM6yrLidOaNdMWeOuGXNly1divpRmeTzvXvv+endP/z+D7Z9+mmWJMd7+Xy+9997b8G8+c8/91xbaysmw1CcOHHivnvuzebkeERXV9cD991/9OhRSe1VKBR68P77szk53mvv3r0/f+jhtF5zHQwG77v3Z/hGDTD45/hbb74575prX3ju+UQkxwmC6BYjjdzpF22ptkCwBCHC93CS4DB/JIInxWlHTIlRxzwi1xz+x8p46xA2nE7GFQp+v//fH3ywaP6Cp578zalTpzCdkqCxoeHeu+9BcjxOmzZuvPXmmx+4736JJ8d77fv88+/d+d3XXnk1hutTsys/Hg6HV3y0fNH8BS8893yDy4W5PpAvDx785SO/uPXmm7ds3nzOBze73S++8PuYn+vVv75SVVWFmCdCR0fHJ5s2ibjB2ZdcIm4KO5pMJrvqmqtF3GBTU9P2bdswDTLAF1988ZO7fnz3T36aLp/KCcJxXMXiJQvmzX/tlVe7u7sxMQYRDAYf/cUvEaXen2S/euQXPp9POrv0lz//+YsDX2BoIvbu2fOPv/09fff/D79/8cjhwxhHgIE+j9556+1511z7yst/TWiaxtsVb46vrpk0aUVbWUITYp2fpjCLJIInNFLbpVyTsPoz9nh97JOko5ts9iRvjnEc9/Hq1bfedPNvn3qqsaEBkypxBEF47NHHPHE0PYbt27ffcdvtj/7yV1Un0ixfx3HcG6+/fsettw33C2oWfd5sWL/+putveObpp5uamjDXh6LqRNUvfv7I9+64c+dnnw3ysL//7e/x5CA4jnvlpZcR7URYvXKVuA2y5i2Yn9Adnr9gAUmKeQK/YkkFpkFaO3ny5IP3P3DXD36YhfWjBxIIBN54/fUF8+a//6/3UOd3IG+9+aZ0OsZIQWNj4xuvvy6RnTl+7Nji/3yIQYn2zttvp+m6jcOHDi//6COMIEB/4XB4acXShfPmv/zSSx0dHYl+uub2eH/Xf/gJa9aLlh+nBHHqooTRL00yQqRojZ34sDi/+AxaQSCI59+Th2OduYdOpSAhxvP8qpWrblh0/e+ffwEXhibIyuUrRKzdmm0O7N//ox/88KH7Hzj21Vfp+yqqq6t/+P0fvPn6G8P45MqG0T169OiPfvDDxx99DL+WY3DkyJH7f3bfvXffU11V3f9/vV7vx6tXx/kU27dvr6urQ6hFt3RpGnTmjOZ0Oi+YdoGIG9z52WeNjY2YCenI6/U+/9xzt99y647t2xGNs8TH4/m/P/3p9ltuPbB/P6LRh9/v//f7HyAOfSz+z4cSWVD/5htvZluJpHPiOO79995Pxz1/8403UMoMoL/PP//8jltve+7ZZ0+fPp2cZ6xtjivheKqJOlglYq9g0da7SHDNctbqIa1ibSocFueDg6YIjVL4spqu2MLGtoXdR1LWIjsUCi3+8MNFCxa+89bbWPIiunfffRdBiEFLS8sTjz/+4x/ddfCLTLjQk+O4V1955d6772lraxvK4zM8P97e3v67p5/+nzu/mxmjm0J7du++/dZbn3/uuT61XDdt3BRDWZ8+BEFYv24dgiyu/fv21Yha2ixxnTmjLVy0SMSthcPhpRVYQp5+KpYsuX7BworFS+I/vGS26urqn9z1498+9RQuHoy2dcsWVFbpz+/3D6uzSIL4fL6hlG7LQuvWrUu7RHNHRwdOYQL00dba+tivfnX3j39y4sSJZD7v8fq40nwvVchsRtEOQWFCtJwjT2oxqSSih8wTa1OseFcFyGUEQRB/WSI72Tjs1JYgEJv3p/gCBZ/P9/JLL918w43b8XkqnpMnT9agyPswcRz35utv3LBw0bq1mZaa27N79+233jaUVWWZnB9f8dHyGxYuWv7RcixTEufbCc9XLF6yaP6Cj5Yt671z757d4kzZXbsRYXGJmxdmWfaqq69Owm7PmDnTbreLexxAjjWNHD927Ht3fvf5//dcEq5EzgyCIKxaueqGhYuij8xZbu+evQjCAN8OU1/B/8D+Azgmn5XX40lyNk2M0dyP0QSItnLFiptuuHHjho3Jf+pDJyku1hWoWw7Q2w4yBo14xVXEa6op4ppliFOALBDxygCfSEVAaVIgCCIYIh/7m2K4XWo//4pubJVEQqy2tvah+x945OGfJ+2Kk8y2c8dnCMKw7Ni+4+Ybbnz1lVf8fn9GvsDW06fv+endiz/88FwfXpmoweW656d3P/P0052dnZjr4urs7Hz2md/95Ed31dTUEARx+JA4HZmOHDmC2Ir5M9vr3fzJZhE3ePHs2QaDIQl7TlGUuAvV29vbN23chCkhfaFQ6LVXXv3end9Fn7cYdHR0PPvM7x68/wEUMSQIoroaPZ8Hikx1yvfh5MlqDMSAwak+mV47nHb9mgAS+EHs9T784ENP/+9vU3WC3x8kv6yOZdV2Rzf5wvtygiC0KsldwiKQMo7QY3ZJBE8oe0ibWFs71ShOJqq3Ukt1I/XEPxXDqlPy1hpWUhHeumXLTdffgCUv8WtsQoXVofJ6vU88/viD99+f8RWPOY77/fMvPPvM7wYpZ5SB+fEP3nv/lptu3rtnD+Z64uzfv//2W279+2t/E6vZaSAQaHa7EVixrFyxoqenR8QNzk9wZ85o182bxzBiXulWsXgxpoTEHT927M7bbn/j9dexFDEeO7Zvv+Wmm6VQQyPF3/M8XkyGs2ofWum9RH8Lx0AMxONpT7MZlW47DJCoX0b79t12y63bPv00tbuxfk8s35+feUd+2ksRBCET6dt3h0+0VxQk8zG7JMVHjRJrU4EeUpQi5P7gN0vat3/JPPH6UFPkW7+g9xyVXPfXrq6uZ5/53T0/vbuxoQHzLWatWIY/NOvWrrvp+hsyr6DKID5atuz+n93n8539gyqj8uNtbW333Xvvn/74x0AggLmeaD09Pf/8xz9ErJXZgqOYiG/7pWKednY6nZOnTEnazpvN5otnzxZxgwcOHDhZjRWL0vXu2+/8z3e/V40xEoPH4/nlI7946snfDPSpnw1IksRMOCsplJsjCYzOwAPEh7HDAGnn3x98cO/d9zQ3N6d8T9btYbqHeWX8W2vYLQf+myKkREoMBHpEO877yUJMMEnppkaLtSmjVuidezHjeMIXOGO+bfyceeiv5y600txOPvcvhWTjvHfPnttvvW3d2rWYcjFODKy4OpeWlpaHH3zoiccfb2/PurUOe3bv/vGP7jrrVdeZkx/f+dlnt918y66duzDX01QXiuGI5PO9e2tra0XcYHI6c0YTt0snQRBLFi/BxJAgj8dz3733vvSXv4RCIURDRB+vXv3dO+48efJkdr58g9GIOXBWen3qr1JPTqmuNKXT67DDAGmE5/lnfvv0H1/8g0RyMV1+8sPNw6gXsW4P8+oyee/NEC/CPoQ4Qq8WbflUgCzBNJOUHrloS6ZyTOG34y5v0uIh+8+2nYeYO59RVZ4cMNPV1Ebe92dla4ekT9h3dXU98fivf/vUU5laDzqx33jxbXNQKz5afvMNN6b8mqcUOvbVV3f98EctLS197s+E/Hg4HH7pz3954L772yRw4TDE/nEraj2QbLa0YqmIW2NZ9uprrknyS5g0eVJRUZGIG1zz8ce4rERq9u/bdytOaiZMbU3N97/7vQ3r12fhay8uKcYEOKui4tRHpqQUyY4BFRSm2UrJ4mKMJmSvYDD48IMPrVi+XFJ79ebHssbWIWX9Nn3O/OZ1RXRu0R8QIV24o5KWi1fSuVu8ah4QM5lMZjIanPkOi9n07AtvnBSpbrhSTlS5qM3741pC7mo5+87Ut1A/fE715Ovyo7VnPKCHIz7axtz5jEqsV5Foq1auuuPW2459dQzzcHjfT4rwW+DsPB7PIw///Jmnn+7q6sryUNTV1d3945+0nrmKPO3z4x0dHff/7L5333lHxEIfkBIYQbEOeVs2bxZxg0nrzNmHuEvIu7q61nz8MaaHdCz+8MN7774HteESyufzPf7oY//3xz/xPJ9VL3zKlKkY/bNHZuqUlO/DuPHjWZbFWPSnUqlGjx6dXvs8efIklDOC7NTd3X3PT3762Y4dUtuxQA/5y9cU/uDgv7mId9exj/1d0af6c3vX/2fvrOOiyrs/fqeH7g5BSkVFREVBDCxsBTEAKXvXWnONtbu7lbJpxe7AxEAURBBBQgFBmgEmfn+4jz9WXRfhzMy9M+f9vPbZXRY/d+7nnrlx7vme09Svs0hE3H0B1tCZV8e8/fjjZyyAkzg0Go3D4WhqapgYG7WwsbaxtjQyMnz7Nj3Qz+9FYuKt5wyoDakoEXui2XVNWH2Rnvuv6SwRQVx6xPJfozhsoeKC/dyVIZyZO7gD5iqtPcotraTSlSs7O3vi+PHnz53HyPyF+5MOHdCE77lz+7bXqNG3b91CK77w/v376VOn1u9KSu38eFpamr+v36OHWH6IIH8Td+YsbKsKSU7mrM+AQQMVFBQABaMiozA8yIBAIFizevWmDRuxMZxkOHH8+PSpU+WqRqBb927Kysp46L+By+X27tNH6h9DQUEBdsKEzODaqxeDwaDWZ9bU0nJ0dMRjh8gbPB5v5vQZSUlJ5Px4qe8Z07YpFJf/OAP4oYg2axd3VxTn+7qk/OKmJg3jkxi1cDd395KIA3v3z5s9a+6sP/bu3nX54sWMt+nYkU9MMBgMFWVlXV0dMzPTli2sra0sjAwN1NXVWCwmQRAnj5+YMXXalz7Flx+DveRmM0XvC+jHrjReMCnjv6+bH4vpN54xz91nPUhmVlTTKHrOWbFs2aYNG+Wt5KXRWNtYm5tjCfn/U11dvXb1mrmz52DLjW94m/52yaLFX0t1KZwfv3Xz5oTAcXm5uXhQEeQrMdGQzVUkPJmzPkpKSn379QMUfJOa+vLlS4wQ6VJZWTlj2vQzMbFohSR5kvBkQuC4jx8/ysn+crlcz1Ej8bh/g/sID1VVUnSL9vP3w6Lj7xMT3mN9qPjJA8aPw8OHyBV8Pn/OrNlJL16Q+UO+fMcYtVTx2BVWUenfJ1u+gEhMp687xvFconj/1Y9LvN/nNykzIBASe2I4akpge3Hv5d+pz5LPn58mJISfOrl21appUyavXrH8aEjIrZs3sjIzsdii0dDpdCUlRW1tLRNjI2sry1YtbczMTPV0dVSUleu/rK2trV3615JtW7d+tTojj56WQwf6DARBEEfOsTM/NkZQKCISXjPk55BFhIf/NnlySUkJRm9D8PX3RxP+viIkJXmP8YqNiUErfsjdu3fDQkO//DOTovsQfur01i1bhEIhJT6tioqKppaWsrKSkpKykpKSoqIih8thMVkMJoPFZNHpdKFQKBQJ+Xx+XW0dj8fj8XhVVVXlZWWlZWVlpaXl5eX4qhBpCI8fPcrJyQEUlPxkzvqM8BwBex6Pjoxs3bo1xom0KMjPnzl9RkZGBvk/KpPJ1NbW1tDUVFNVVVVTVVZWZrHYLBbrS1+Iur+praioKC+vqCgvL/78ubCggMxDFN69ezcuIHDz1i0tWshFK08/f//Lly7ngp4PKY2evv7ESZNI8mGsrK09RoyICA/H4/KVkaNHUbTQyc7ObvCQIWRrwYwg4mPt6jUJjx+T/3OWV9F2RnIOxKmaGipraigKaBoKSuoKitwBg7hcLpfJYjEYDCaDSRAEX8AXCUUCgaCmtqacd1qF28hhgGfjmRl59B72MAlrvoC4k/iDTIVAIMh89y7zfxPIGQyGsYmJiampsbGxoZGxkbExSd4Ekw0ajcZiMbkcLofL4XI5ClwFDof9n3+qrKxs7uzZic8Tv32kus2a51UDcJT5BEEQtXzakkOcQ39Ws38xNZXwmvFNpxQ2m62to6OmpqaioqKioqysrMLhsL9GO1/AFwgE/Lq6mpraiory8vKK8vLy0tLST4WFVBmElvg8MdA/YOv2bc2oNrBE8vQf0P9MbOyzp0/l3IeQ4OCD+w/gq8Sfc+jAwe49ejRr1oyS+fFdO3YeDQsj4QdTUlIyMzczNjYxMTExMjY2NDLU1tbW1tbmcDhNkRUIBMXFxUVFRYUFBXl5eR8/fMzOzs7KzMzLy8O8OfKPmxXqT+b8JofSpk0bwOWrV69cnfHHH3jfLBXeZ2VNmzotn5QlzEbGxlZWVubm5mbmZqamprp6elpaWo3QKSkp+fjxY1ZmZlZWVlZmZlpaevb79+SZrFD06dOUiZNWrV3j7Ows8/HG5XLXrFs7ecLE6upq/PYpKiquWbeWy+WS5yNNnzkjJSX51ctXeHQIgmhrZ/fb779T9/PPnjsnPS0tJSUFDyUi84SFhJ6LiyPhB1NQUDAxNTUza2ZsYmKgb2BgaKCrq6ulra2k9Ivl3O8+EcXnGvEBistpu6M5BEEwgVanP0xmNKRJtEAgyMrMzMrM/PoTFRUVYxMTQyMjPT19PX19AwMDdQ0NeVu0RKPR2GwWh81hc9gcDpvL4XK5HDr9147Nh7y8mTNm1vf2KxceMn8bXqPc5EaYVTV/H5c3OYzNJzkLfH4t5/48u/mgwR1MTE1MTU2NjY11dHUbPTSrpKSksKAgJyfn/fv3uTk5795lpr15w+PxSHhw83JzJwSOW79xg3379nhO/jnLV64Y5x9QWFgon7tfVFS0dPFfCQkJVDlrSfGpuba2dse2bZu3bqVYflwgECxbsvTK5cvkeQK3bW3btq2dtY21tY2NkZGROLbCYDB0dHR0dHS+qfvj8/lZWVmpr1+nvk5NfvUqNTWVKm8+EXFQXFwMO2xBWpM56+M+YgRgfrympubc2bgx3l4YLRIm7c2b6f/rWkgGWCyWra1t+w4Obdq0aWVrq6amBiKrrq6urq5e/0RdXl6ekpzy8mXS40ePXyYlSb1pZnV19bzZcxYvWdJ/QH+ZjzobG5tNWzbPmTVbzlPkXC534+ZNtra2pPpUbDZ767Zt06ZOTX2dKuenx5atWm3euoXSM0u5XO62nTtmTpuOKXJEtklMTNy3dy9JPoySkpJt69a2rW2trUEfQtW6Ni4/vuE4p7yKRhAEnQ6T4Dj/oJFnxfLy8pTk5JTk5Pp3fXr6+itWrdTR1aurq6utra2rrautq6PKSvT/ShTQWSw2m81is9lsFov9P5r4RuB1SsqsmX/8W6vi6hpa5C2Wn1uTbmv5AqKi6v8/ZexdVjM9oVefBmtym01cEEMQMG8+vtzDW1lbf/2JSCT6kmlJepH07NnTjLcZ5Cl5KSsrmz512uIlf/Vzc8Mz80/Q1dXdtXfP9N+n5ufny9u+34u/t3L5cvI8fdc/IVtaWdna2lpYWhoZGRkaGaqpqSkqKjIYDB6P97m4OC0tPfX16wcP7qckp0jyLB1/N/5dRgaNPN/z/z6H8vkL/1wg9XGrTCazTdu2Tk5O9u3tW7ZqRZ5hSnV1dSnJKc+fP3v44MGLxBeUm16yYdPGbt2743m80YQEB+/dvQdQcNee3R06dpR6VA8aMLAUrs+aqanp6cgIjBZJkpqaOv33qaWlpWS4SerazcXFxcW+fXvJ19LW1NQ8e/r09u3bd2/fKSgokKIPdDp9/oI/hw4bRhBE2ps3Y73Buh6vWLUSdmxA08nKyvpr0eI3qXKahLW2tl62YkVzi+bk/Hg1NTWbN206G3uGQveigNBotCFDh86eO4fNZsvA7tTU1OzetSsyPEKuljZqamqev3QRL/TyQEVFxVgv7w8fPkjxM7DZbPv29h07derYqZO1tbVYaqKFlUSiCyH8xbJZnZHZtJ+SnioAACAASURBVHEJjxMSHj+2VL4a4NbUkeBFpbShCxX5AsgdDAoJbtmq1T9zC4K6ujo+v66ujl/H//J3fl0dXyDg8/kC8lyY6HQ6g8FgMhks5pf/MVms//8HceQinj97NvuPWZWVlT/5HQ0VUdSqSoUmLJL/UEQbvujb9Q2zR9d49mhYEsPqIKEquQWRpaWlTxKexN+9cy/+HklyjnQ6fc68ue4eHnh+/jklJSUrli2/Fx9P0c+/cvXqPn37NPz3BQLB7l27Thw7Tqq7a2sbG8fOjo6Ojnbt2jWwKKS4qOjs2bPRkVESm6EVMC6QMvnx2traeXPmPrh/X1ofQEFBoVv3bt179HDs3PmXl6pJnOrq6gf379++dTv+7t2ysjJKHGLMjzcR92HDAcfVmpiYhEdFkmG/wPsp7dy9q2OnThgwkuH169fTf58q3bOQpqZmPze3fv3dyNN6+3VKyqWLly5dvCitGeI0Gm3WnDmeIz1lPj9OEIRIJLpw/vzJ4yfevHkjP189axubUaNHDRg4kPyLyl+npIQEh9y5fVt+eiMymUznrl39A/y/SdbIABlvM0JDQm5cv15TUyMPhxLz4/LDmtWrpTVdXFlZuXuPHt26d3Ps3FkSb/ezlhCffqWURNmesA4maH/nO0T5obScdU38CIfi2IfigF8cfp8f/zkCoVDA5/MFAgFfIBAIhEKh4O//CQUCgUgoEoqEQqFQJBIJ//67SCQSEYRIJCL+l2AR/e+eq/7/0+g0Go1Op//9NxqdRqfT6QzGl7/oX/760i+byWQwGIxf7YvSRB4+eDB/7ryGtBaZOLg2cGDjF68/eMWYufMHLVr83GonDa2l//zmRc+fMJ4nrbPBy5cvr1+7dvXyFenWu3yJp9+nTfUZOxZP0f8db/fvHw07+iQhgXI1Gb+UH/+Ql7dwwcL6C2iki00Lm969+/Tu09vA0LApz3GHDhzMy8sT96ft0KEDNfLjPB5v1sw/nj55IvlNMxiMLk5Obv3dXLp1a2IbcakgEAju37t38cLFu3fukLOF1lcwP97EW5kZ06YDCk6dNs3HlxTX2tzcXE93D8DFNT1dXdeuX4cxIwEyMzMnTZhYKqUx63Q6vYtTF3cPjy5OThJ+tGggQqHw/v37URER9+/dl8oi36nTpjl2dpT5/Hj9gHxw735a2pu36W/fv39fVVUlS183RUVFU1NTC0sLKyvrzk5dzMzMqPX5y0pL4+PvvXr58u3bt+8yMsrKymRj5fvX05GGhoZ58+bNm5u3srV1cnJSBWrrRE4qKysfPXyYlJSUkf727du3xcXFslpUjvlxOSExMXHyhIkSfmpmMBidu3QePGSIc9euEm3BVJNNJA8mhA3Le3LNCZujBFPj/3/y+SKRMasp26+uIYYuUCqrAn65+6v5cfnk9q1bixcuamDLVgWOKHxFlbZaI78XoRdZe2K+za5wOJyerq6jB5u34IYRtf+yXEPXizBZBNVZpSk8e/r0XNy5q1euSDfNMn7ChPETJ2D0NoSC/Pz4u/EpKcnvMt5lZmZWVFSQPx3a8Pz43Tt3VixbTobqWBUVlf4D+g8dPtzCwgJEUCAQnDp58sC+/WL9rplSYj4nn8+fN2eu5JPjWtraQ4cNHTZsmK6eHnVPAQwGo6uLS1cXl4qKinNxcbHRMRkZGXhmlD3AJ3MOHDyIJLtmZGTUydERcO3Indu3P336pK2tjWEjVj58+DDtt9+lkhxXUlIaMmzoCE9PMc2EgIJOpzs7Ozs7O+fl5oaHh8dGx0g4Y7tr5860tDT5iUkzM7P6WWOBQFBVVVVdXd3wPOz1a9d2bNsOGwN7D+zXa8JtBp1GU1BU/NK2j9JHR1VNrf+A/vU74/N4vMrKyiY2i4s4HQ4+0X37zh3NGvz6gcViKSkpkWo4qmROwj1dXXu6un79SU1NTWVlJUnG5JyLizu4/wBeppGGs2n9BknmUJSVlYcMGzpq9Gg9qTyEckwI/YlE3q7//k0FC8LqyD+S4wRBsA2auP3IWyzw5DjSEG7dvLlowcKGr+WqrqFtPc1ZPaGR6apnaf+4bzExMRnu4T5o0KC/3x+LvInCE8SncKL67f//kmILwnA6odaDJI7Zt29v3779H7NnXTh/PjI84t27d1L5GIcOHhQIBJOmTMYY/k909fSGe7gPJ9y//qSqqqqqqgp8CaP70GGSrPMQiUQH9u0PDgqSerrfwtJijJdX3379YJsHMhgML29vFxeXFctXJL14IaYPT6PRyJ4fFwqFixYsfPTwoSQ3atqsma+fb/8BA6j+tPnNndao0aNHjR798MGDsNCwhMeP8fwoMxQVFd29cwdQsFv37hoaGuTZwRGeIwDz43w+PzYmZtz48Rg54qOstHTG1GmSHxeupq4+cuTIkaNHqaioUMguQyOjGTNnBgQGnj556tTJk+Xl5RLb9KWL8lv5yGAwVFRUfilURo4adeLYccDAFgqF169e+2P2LDxpfA+Xy21iWpnP51++dAn2U3Xs1Mmxc2c8Or8Kh8MhzypMNZku3kfAuXL5isTeJaupqY3x8ho5epSioqI099lgClH1kii5+dPP6kyYbyUYyt/+XMGSoNGIxuZoyippwRfYGHWS5+GDB4sXLvrVLOG1J8w+HZg97H85t1hT9//58ZatWvn6+fbo2fMfHeFoLELXl9D1Jeo+ErxMghASHDOCbUhC65SUlEZ4eo7w9Lx7587R0LDnz59L/jMEHTnC4XD8AwMwkn8VRUVFKZ9vm8znz5//WrgoISFBuh+jc+fOXj4+nRzF2MbWxNT0wKGDhw8eOnL4sDheP2hqaJA9P7565cpbN29KbHPm5ubjJozv1bs3+ft1NhrHzp0dO3d+mZR0YP8BCb94QMTE2dgzsO88h7sPJ9UOOnftqq+vDziZITY6JiAwkJw9N2SA2traObPnvH//XpIbVVBQ8Pbx8R7ro6CgQFHfVFVVx0+cMMbbKzgoKPzUaZJ3xJJPmEymt4/Ptq1bATVjY2ICxgWqq6ujveBcOHcevDeof4A/Gosg8oNIJDq4f78ENsTlcr18vH3GjiVHpoZGNN9OZC0hin7Ucp2pRhhOJXS8f/xH6UoEx5TgZTVuwwfOsiuqsXhc0jx/9mz+3HmNW7C1JozTykygq/Frb0TuJDJ5tTTb1raTJk/5j4QaS59g6VPCxi+r9hMTE/ft2fvs6VMJb33f3r1cLne01xiMZ/n68j5/vnjBwk+fPkntakGjOXftOn7C+BYtW0pmc+MnTrBtbbtsydLS0lJYcXOL5qROD+3asfNc3DnJbEtLS2ven/OPnTzRu08fGU6Of6V1mzY7du3cvW+vlZUVnlaoTmxMDKCasbFxh44dSbWDNBptGGjKvqCgALbiHqnPimXLXyQmSmxzdDp92PDhkdFR4ydOoG5y/CtKSkq/T50aHhU5cNAgebgYUY5h7sNhc9k8Hu/k8RNoLDgikSgMurNK69atHTp0QG8RRH64c/uOBN73d+/R/XRE+MRJk0hUxkhjEWZrCatDhHpPgqlCEARBZxPK7QjjeUTrS/+aHP+CimPjtvnqHT3yJgujTsKkJCfP/mNWo8syyqpoc/dyeb/YPetBerMNmzYdDgoSa7WpVLCzs9u7f9/2nTtatGgh4U1v37btTGwshrT8cOzo0alTfpNicty5q3NQSPCmLZslkxz/Shcnp+CwUAtLC1jZDh06kDc/fiY2Frxl5A9hMBhjvL0ioqPcPTzkrZ7UwcEh9NjReX/Op1YvAqQ+9+/d+/DhA6DgsOHDSbibQ4YOhZ1NFBkRgcEjDoKPBF29ckVim2tla3skOOjPhQs0tbRkyUYdHZ2/li45cOigpaUlBhWp4HK5o8cA1+ZEhIdXVlait7DcuH7jfVYWrKavvz8aiyByxemTJ8Wqr6auvm7D+vUbN5J03pWqE2Gxm7B7SLR/Rtg/I2yOE3r+BEP1v/aqeyM2xaslVoRwRRhzkuXDhw+z/5jVxJuQ1PeMxYe4/AaPYf7EM1u04Uy37t1k2FjHzp2Dw0IXL/lLS4JPKCKRaMO69YBdSRHSwuPxFi1YsHP7DvDO6Q3Eyspq9949m7dulXBm/CsGBgYHDh1y7OwIJaiqqtrVxYWk6eAnT55sWLdeAhtq0aLFkZDgGTNnykDVYeOg0WjuHh4nw0/XH6OEUAgZnsxZH01NzR49ewIKPnr4KCcnB+MHlrt37hyQyDJkgiAUFRXnzp93JDhIWldlCdCmbduQo2G/Tf0ddsIJ0kQ8R41UVlYGFKyoqAg/dRqNhSUsJARWsLmFhWw/zCMI8g15ublPnjwRn36HDh2OnTgOe38rtidGDkE0eE2bqsu3QzsbwKaTnKyP2PlQolRUVMyaMbO4uBjgEeAFc/Ehbm1DMnV0trbDTjlZIjlo8ODwqEgvH2+JjbXj8/mLFiyU2MgERCrk5OQE+gdcu3pNKlvX1NRcsGhh6LGjUl9SqaSktGXbtsFDhoCoefl4s9lsMl6Est+/XzBvvrjfhDAYjPETJhwJCbaxscHvmJaW1tr165avXIGF5NSisLDwXnw8oCDZJnPWx2OEB6CaSCSKjozCEALkQ17e8qXLJDOqu72Dw7ETxz1GjJB5VxkMhq+fX0hYqOQXaSI/uRsDj72TJ07U1NSgt1A8evgoJSUFVtPXzxeNRRC54urVqyKRuAqa/QMCdu7Zra2tLYPG0ZiE7q8ttLr0TDvuHnZWkSgCgWD+3Lnv3r2DErz5jDltm0JR6U8T3zQa0WwlwbWQH58VFRWnz5hx8PDh5hYS2uvKysrZM/8AHCaPkIr4+PgAX7+Mt28lv2k6ne4+wiM8KnLosGEkecXFYDAW/bV4wqSJTdQxMjb29vEhCIJ0+fGampo/588vKysT61b09fV379s7fuIEHNBXn35ubsdOHG9rZ4dWUIWzZ2R8Mmd92tnbw95YxMXFNW4QDfI9fD5/4YKF5eXl4t4Qk8mcPnPGnn17DQwN5cde8+bNDwcH+fn74zWLJIzx9uJyuYCCJSUl0VH4xg6M0OBgWEFDQ8O+/fqhsQgiV1y7elVMdzKLl/w1+bcpslxCq+tLsBpccKM5sLv3xS5OThhykmT9unVPEoCXRySmM7xWKJ6/zxT+8L0SQ4kw30hoDpZDt1vZtgo7djRgXKBkCskLCgrmzppdW1uLcS5jHDl8eO6s2RJ44v6e5s2b7ztwYN78+UpKSmSzZdz48QsXL2IymY3744qKimvXrfvSy5d0T9ob1294my7elyEdO3UKO36sXbt2+AX7wc2Mnt6+A/t9/f1wLhz5EYlEsTGQIzhIOJnzG2BLyEtLSq5euYqBBMLunbtSkpPFvRUDA4P9hw56eXvLocMMBmPK779t3bGdtCs85Ap1dfWhw4bBah4LOyqtHoIyRvKr5ISEBFhNH9+x+HYKQeSKkpKSN6lvwGVZLNaGTZsGDZb1FCFDlTBZ1KDf1BpGmK/nKihu3LwJsJMs8nPOxMaeiRHLIMfSStqKEK7PSsXwm6z3+XSRiCBoNIJjROj5EbbnCI0Bcus5g8GYNHny3v37DQwMJLC5169fr1+7DkNdZqiqqpo/d+6Bffsls1a7Pmw2e+LkSWHHj7W1a0taf4YMHbpx86ZG5O5ZLNaqNWusbay//Cu57vXjzp6NO3tWrJsYOWrk9p07sIvIT6DT6b/9/vvqtWtJNEId+RH37t3L//gRUBA83QNO/wEDYMMyKjISA6npPHr46OSJE+LeipOzc9jxY7a2tvJstaOjY9jxY61bt8aokzreY31ghwYXFhaK+xZITgiF7jyupaUl+8ksBEH+ydMnT8CbqzAYjOUrVzg5y0ehtMYAwvD3nz5zsgnjuYTZmi8ZCSaTuWHTpjZt22LsiZvXKSmbNmwU6yYy8uibT3K2XHAttbhL2D8nWl8hjOcTLF00v61d26Mnjrv26iWBbZ2Li8NuorJBVlZWoJ//rZu3JL/pVra2YcePBY4bJ7Ee+o2mi5PToSOHzczMfuEOX1t7x66d9S/KJMqPZ2ZmivVMTafTZ8+ZM2vOHKwAagiuvVwPHD6kR85Z6ghBEAQBe8FjMpmDhpD9+V9RUdGtvxugYNKLFzjApImUlZWtWLZMfA06v+AzduzmrVtghyJSFG1t7b0H9rv1749WSBddXd0BAwfCaoaFhkm+KkT2HiFu3wJ+fhg9ZgzOyEUQeSPxeSK45pTffpNMXowsGPxONFtOMH5086bWlWgZTugF1P8Zh8NZs24trpMT7317aemf8+aLu/MGjUYLCAzcumO7uoYmQcPO8v9ASUlpzbq1v0+dKoGE45bNm1+9eoWeU5oH9++N8w/IzMyU8HaZTOaEiRMPHTncrFkzqnhl3rx5yNGw0WPG/GevFSaT6TFixIlTJ+3bt6//c7JkioVC4Yply3k8nviO7rIVyz1HjcQvWMOxtLQ8FHTEwtICrSAhBfn59+/dAxTs3qM7Je5H3aHH4kVjCXnT2Lxx46dPn8Snz2Kxli5fPnX6NGz6VN+TZSuW/z51KnoiXXz9/WCfbXJzcq5cvozGNoWwkFDYdwwqKioeniPQWASRN9LTgesnunbt6uM7Vu581PYkWl8ijOcR6q6EcjtCzYUwmEy0iiEsDxBcq+9/XUdHZ9mK5Xh7Iz5Wr1r1EXT98fcoKiquXb9u0pTJeBx/wlg/3207tqupqYl1K3V1dX8tWlxVVYWGU5dzcecqKiokvNHmFhZHgoPHTRhPudpiDoczc9YfJ06f8vbx+b6WnMvldnJ0nDp92pm4s3Pnz1NVVf3mF5gk2Y3goKBksb3aYrPZ6zZskJe1bKDo6Ojs3b//jxkzXr3EF4/k4kzsGYFAACg4bPhwSuy4paVlWzu7F4lgRT0XL1ycOn06dhNqHLdv3b508ZL49JWUlNauX9/JsRNa/cMbax1dnVUrVmLTamlhZGTUu09v2K9ASFBwPzc39LZxFOTnX7xwAVZzhKcnXiAQRA5JBx2IpaysvHDxIjm1kqlB6PkTev4N/HXHzp379ut36eJFDEJwzsaeEXeLBh0dnS3btlpZW6Pb/0nHTp0OHTk8c8bM3Jwc8W0lLzd388aNfy1dioYjDYFOp3t5e0+aMhm2jaSEMTExmTZj+rQZ06urqwsKCqqrq7lcrrq6uqqq6s8z/qR4G5D25s2RQ4fFdUVmMletWYPJ8Uajqqq6Y9euVvLd85dsCIXCM7HAkzk7dqJMChJ2SmdVVRV4PkVOqKys3LBOjINfNDU1d+/bi8nxn+DWv//mbVsxeSdF/PwDYMujMjIybt28icY2juPHjsO+LuJyuaPGjEZjEUQO73BKS0oABb18vDW1tNDYBvLb1N//c3U88qvk5ORs3bJFrJtobmFxOOgIJscbjomp6eGgI7atxZtpORd37trVq+g28p/o6uru3LN76vRplE6O10dBQaFZs2YtWrQwMzNTV1f/z3J46efHhULhyuUrxFT+xmAwli5f3q17N4z1pqCkpLRj105stEIe4u/eLSgoABQk/2TO+vTq3Ru2FUxUBLZYaQz79+4VX2eVL122W7RogT7/HEdHx607tjdiWjcC9CjYHPweIzgoGI1tBGWlpbExMbCaQ4YNVVdXR28RRN4oLCwEVGOz2SM8PdHVhqOnp9enb1/0ARCRSLR8yVKx9tlo167dwcOHdHF62S+irq6+Z9++Lk7ireZcv3ZdUVERuo38BJdu3Y4eP+bg4CDPJkg/Px4ZEfnmzRsxic/8448+fftgrDcdZWXlrdu2aWtroxVkICY6GlCNEpM5v/nAg4cOARRMT09/kfgC4+qXSE1NjRTbewVdXd29B/ZTaBiIdLGzs9u+cwcOL5UW/gEBsIIpyckPHz5EY3+V06dOV1dXw15rfHx80FgEkUOKQF//d+7S5fsmp8jPGQJ6q49EhEckJSWJT9+xs+P2XTuxXKNxcDicTVs293R1Fd8mysrKtmzahFYj/xaBc+bN3bh5k6qYG+KTHynnxz9//nxg3z4xiY8aPRoHcgKiq6e3buMGmVlqQV3y8/Pv37sPKEiVyZz1Ge7uDjssIjIiAkPrl9i8cRNsB/yv6Ojo7D2w38TEBE1uOK3btNmxaxc+lkiFlq1adXJ0hNUMPnwEjf0leDxe+OnTsJr93NywDg5B5BPYl20OHRzQ0l+lnb09Lt+BorCwcN+ePeLT79a9++atWzkcDlrdaBgMxpp1awcMHCC+TVy7ei3+7l20GvkGC0uLoJAQXOT0BSnnx3du315eXi4O5a4uLjNn/YEHGJbWrVtPnT4NfZAusTExQqEQUJAqkznrY2Bg0MWpC6DgjevXS0tLMboayJXLVwBHpNZHVVV1284dRkZGaPKv0sq21YZNG9lsNloheQICgUvInz17liier5isEhMVDXsOp9Ppfv5+aCyCyCc1NTWAas2bN0dLfxUajdbeAd8rwLBl0+bKykoxiXfu0mXNurXYLx4k5v9aurR3HzE2P9i4fgOPx0Orka+4e7gHhYQ0t8CL1P/u/6W47devX184L5axeKbNmi1fuQJ2ZBbyhVGjR1NokKPsIRQKz8TI72TOf5zNR4wAVKutrT175gwGWAO92r1zpziUFRQUtmzbamGBow4aiUOHDitWrWQwGGiFhLFv376tnR2sZvCRIDS2gQgEguPHjsFqdu/RwxRbPCGIHJ9VANXU1LAOujHYtLABVGPK6xro+/fu3bh+XUzi7R0c1m/cgMlxKGg02vKVK1y6iWt43sePHw8fPIQ+IwRBKCkprVqzet6ff2JxVX2kmR/fs2u3SCQSx5HesGkjLjMXH38uXIDrp6TF3Tt3YCciUmsyZ32cnJwMDQ0BBaOjojHAGkJEePjHjx/hr0Z0+vKVK1u3aYMON4UePXvO+GMm+iB5wLuQP7h/PzU1FY1tCOfPnYedWU0QhF+APxqLIHILl6sAqCYUCdHSRgDbak9RUVEOPRQKhTu37xCTeIsWLTZv3YJpAVi+NFpp166dmPRPnzoljuc4hFpY29iEHA0T62IFiiK1/HjC48ePxDN+atFff5mZmeGhFR9GRkaeI7Gxu3SIiowCVGMymQMHD6KoFTQabZg7ZGeY3Jychw8eYIz9nMrKypDgEHEo/zb1927du6HDTWfkqFEeoKsrkIbg5OxkbQNZ6SYSibCEvIGEhYbCCjp2dmzRogUaiyByi4ICF1CtuKgYLW0EJqamgGqamppy6GFsdExGRoY4lPX19Tdv26qgoICBCg6Lxdq4ZXMz8WS0ampq9uzahSbLM+4jPA4HHTE2NkYrvkdq+fHdu3aLQ3bosGGuvVzxuIobX38/vBxKng95ebBvlbp1707pm8UhQ4fCLgiKjIjEMPs5J44dLy0pAZcdOGiQz9ixaC8Us+fO6dCxI/ogYcBLyG/dvJmZmYnG/pwb16+/z8qC1fTzD0BjEUSeUVZWBlTLePsWLW0EpqamUO1StbS05PDRtaqq6uCBA2L6gmzdvk1LSwujVEyoqKhs3bZVQ0NDHOJXLl9JSU5Gk+WQv3uqzJ/Pktd+U/+JdPLj9+LvieM7aWZmNmvObDyoEkBVVXXgoEHog4SJjYnFyZz1UVdX7+kK+T4s/u5d8EX6skRlZeWpkyfBZS0tLef9OR/thby00+krV6/S0dFBKySJay9X2OVrQqEwNDgYjf05odArWlq3bt3eoT0aiyDyjL6BAaDa48eP0NJGwOFwoFqswC7wogrHjx4rLoZfu0Cn05evWmmOU2fFjKGRkZgGn4pEIjHVqiJkxtraOjgsFHuq/Mf5TSpbPRoWBq7JZDKXrVyBDbAkxuChQ9AESSIQCM6ePQsoaGRs3MmR8qNWYftICASCmGjsQv6vhJ86XV5eDquppKS0dv06PHWDo6GhsXL1KpyYJGF8/f1hBS9fuvzhwwc09t94/OhRSkoKrKZ/IBaPIwheQzUA21U/SXgCOz1IfnDu2hVEx6GDg7xZJ6aiFoIgAgIDnZ2dMTglgH379lOnTROHcsLjxy+TktBh+WHgoEGHgo7ADnWQSaSQH09+lfz0yRNwWW8fH2wWKUlsbGxgpyMiP+f2rVtFwJM5h8qALW3t2lpaWgIKnomJFQgEGG/fU1NTc/LECXDZ2XPnwPaXRL7Szt4+IDAQfZAk/dz6wV4Z+Xx+WEgIGvtvgI9DaG5h0dXFBY1FEMQYLo/A5/OPHT2KljYCkMk0NBqtV+/e8mZdRHg4eFELQRCdO3eeMGkiRqbEGO01RkzRe+TwEbRXHmCz2fMXLPhr6RLYtrSyihTy4+BjlAiCMDMzGz9xAh5OCdOxUyc0QWLA1jUzmcxBgwfLhjOwJeSfPn26dfMWxtv3nIuLK4HuPN6te/cBAweit+LDPzAA3xxLEgaD4eML3Ek/7mxcUVERevs9KcnJCY8fw2r6+fuhsQiCEATRqlUrQLXI8AjwSQnygH379haWFk0U6eriYgDaMIf81NTUnDwOX9SioaGxZPkyDEsJs2DRQj09PXDZe/Hxr1+/RntlGz19/f0HDwx3H45WNBBJ58fz8/Nv3bwJLjt3/jzsMS95WrZqCZlWwD4A/05ebu7jR5BZAKpP5qyP24D+SkpKgIJRkTil8weA32erq6svWLQQjRUrDAZj6YrlWC8gSQYPGaKtrQ0oWFtbi4WHPwS8eNzQyKhP375oLIIgBEG0tWsLeyZfumQpn89HY3+VKb/91pQ/zmQyJ02ZLG+mnYmJ/fz5M7jswsWLZOb5kUIoKysvWb6MTodP3IWFhKK9MkwnR8fQo2EtQd/1yjySzo+fgR4wSBBEn759HTp0wGMpeWAbGGmoa6Cl/0ZMTAxO5vw3FBQU3Pr3BxR8kpCANT7fcC/+3vv372E1p06fJqax7Eh9zM3Nx/r6og8Sg8Viefl4A18CoqLLSkvR2/pkZWXdvgW81mfs2LHieP5EEISK2LVruHXlBwAAIABJREFUByuYkpy8dvUaNPZX6eri0pT7/PETJsB2YqQE4eHh4JqDBg926dYNA1IqODg4jBjpCS576+bNwsJCtFf2oNFoAYGB23fuUFNTQzd+CYk+BgiFwrNnzsBqcrnc6TNn4IGUCsag+XFNLXwd/WMEAkHcGZzM+TNgW6yIRKLoKJzS+Q8iI4Dvs9u0bSszHX7Ij1+Av6GREfogMdw9PGDvR6uqqk6KZ8oWdQkLCYV9baylrT1oCJ6UEAT5392ykZG5uTms5rm4uC2bN6O3v8qCRQvt27dvxB8cMnSIHI5cfvTwEXihj4aGBqZcpMuU337T09eH1eTz+dFRUeitjKGiorJx86ZJUybTaDR041eRaH78Xnx8QUEBrOboMWN0dHTwQEoFPT09qGX7DAYDl2v9G7du3iwuLgYUlI3JnPVpbtHc3t4e9gGmpqYGY+8LHz58uH/vPuSFh06f9+d8NFZisNnsWbNnoQ8Sg8vljhozGlYz/NTpqqoq9PYLBfn5Fy9cgNUc4zUGO/UhCFKfHq49wTVPnzy1cvkKHAX/S3A4nG07tg8ZOuSXbjUDAgMXLl4sh3ZFiKF4fOasP1RVVTEUpYiCgsLceXPBZWOjY/B0JEs0b948KDQER803Gonmx8+C1sASBKGmrj7WD5eNSxNjY2OobzJ2yP03oiIh3+vK0mTO+riDlpCXlZVdvXIFY+8L587GwdZp9h8wwMrKCo2VJF1dXBpXe4U0jpGjRsHORSgvL48Mj0Bjv3D82HHYNr4qKiruHh5oLIIg9enVu7dYbqvi4qZO+e3Tp0/ocMPhcDgLFy9evXZNQ9p7tmzVau+B/XLYdpwgiIKCgvi7d2E17e3t+7m5YRCS4WbeydkZVrOoqEgc0wERqdDT1fVwcBBUgk4+kVx+vKqq6sH9+7CaY33Hwj5/Ir9KewcHEB3b1q3RzB+SnZ39JCEBUFCWJnPWx7WXK+x+RUbglM6/OX/uHKAam82eOHkSuip5pk6fhuvsJIaysrL7COB864njx3FdC0EQZaWlsTExsJojRnoqKiqitwiC1MfS0rK1eJ5Qnj175jPG6/q1a2jyL9Grd+/TkRFr1q3r5+b2/Sjs5s2bjxo9et+B/UEhwXZ2dvJp0eVLl2DLgWk0GnZWIQ/TZkxnMBiwmhcvXERjqQ6dTp88Zcra9esUFBTQjabAlNiW7ty+Dftcp6qqCtt0GGkEXZydQNZwdezUEc38IbHRMSKRCFBw6PBhMmkUg8EYMnRocFAQlGDyq1epqak2NjZyHoFPnzzNy8sDFHT38NDT08OvtuSxtbV16dYNfKQh8m+M8fIKP3Wax+NBCRYXF5+JifUcNVLOjT196nR1dTWgIJfLHT1mDEYsgiDf4zlq5MuXL8WhXFJSsvDPBd17dP9j9mx96LbCMgyNRnPt5eray5UgiPLy8pKSEl51tZqamrqGBq5FJgjiEnSus2+/fi1btUJjSYK5ufmQoUNhm4bfv3evrKwM++dQFxUVleUrVzo5O6EVTUdy9ePXrgK/IR85ahS+HpE6HTt2VFNXb6KIkpIS9kj6IXw+/1xcHKCgoZGRo6OjrNo13MMd9o16ZAR2MyCuXrkMqMZisbzH+qCr0sIvwB9NkBiampq/1Cy1IRw9elTO20TyeLzw06dhNYcOGwY7TxVBEJmhV+/e39cpA3Lr5q3RniP3791XWVmJbv8qKioqJiYmVtbWunAzsShNxtuMtLQ0QEEGgzFh0kQ0llQEjAuEHZdSV1cHnqlDJMaXhuOYHIdCQvlx8OYqHA5npNyXUJEBNps9oslV/O4eHhwOB838nhvXb3z+/Bk0CzBUhu3S09Pr4gR5bbhy6bKcP64IhcIb128ACvZzc8OJylLE1tYWqikW0hB8xo5lMiEX6uV//Hj+3Hl5tjQmKrq0tBRQkMlkevt4Y6wiCPJvp4iAcYFi3QSPxws6cmT4kKEH9u8vKSlBz5FGc/nSJVjB3n36YC9jsqGrqws+S+zK5ctoLBXBhuPgSCg/nvA4oba2FlCwT9++qljsQ5Lnf9+xTUl4aWpq+vr7oY0/TgREA0/mHDxkiGw7NsITsudSdXX1+bhz8hyBz54+hX1Dg8Xj0j9jjx2LJkjuGUZPr/+AAbCaocHBsE23KIRAIDh+7BisZv8BA3Sx4xOCIP/OsOHDDY2MxL2VsrKyI4cODxk4aNGCBfHx8bBz0RE54c6d24BqdDrdPzAAXSUhvv5+sOUXLxITy8vL0VgKQafTJ/+GDcfFYKxkNvPwwQNYQey/SR4UFBSWrVzRuHM0g8FYvGSJiooK2vg92e/fP33yFFDQpVs3mZzMWZ/OXboYgb5BjYqU6ymdt29B3mfbt29vbm6OX23p4uTsZGBggD5I8hkGtu9Tdnb21StX5dPM8+fOFxQUwD5djPXFN0YIgvzH08rkKVMks63a2tprV6/NnvnHgH5uK5cvv3rlSkVFBR4CpCF8/PjxbfpbQEHHzp3xvp2cGBgYuHTrBijI5/Mf3H+AxlIFZWXljZs3+Qfg6yt4JJQffwCaH2/ZsiUOzSMVDg4Ofy1d8qspcjqdPu/P+dgs6d+Ijo6GLRIc5j5cHnwbDrqb7969e/b0qdwG4d27d0l7aJBGM3TYMDRBYpiYmLj26gWrGQI3iJhahIWGwgr2dO1p2qwZRimCID+nb7++nSQ7v6ekpORc3LnFCxe59ek7Ydz43bt2xcfHY49y5CfEg960EwThORLrEcnLiJGewA99d+6gq1R5sjgUdMS5a1e0QhxIIj+ek5OTm5MDKNh/4AA8cmSjn5vb3v379Bq8SFlNTW3j5k2Ypvk36urqzoF29pDtyZz1GTJkCOyInqjIKPkMwvdZWYCnbhUVlZ6urvjVJgODhgym0+nog8TwC/Cn0WiAgunp6Xdu35Y3G29cv/4+KwtW09ffH+MTQZCGMO/P+VKZlsTn85NevAgLCZ09848+rr28Ro9ZuXx5+KnTLxJf8Hg8PC7IV+7egcyPGxsbYxEbmXFwcICt7n9w/77ctu+jEJ0cHY+EBJuZmaEVYkIST8jPQHtEMJnMvv364ZEjIW3atg07fszP319RUfEnv8Zms4cNH34y/DS+9fp5IqAUdESPbE/mrI+qmlqv3r0BBW/eAJ6SShUeP34MqNajZ0/YYetIo9HW1rZvb48+SAxLS8uuLi6wmsHyV0IeGhwCK9i5c2dcjIggSAMxNjaWWJeVf0MoFGa8fXsu7tzmTZsmjh/fq0dPT3ePeXPm7t295/y5cynJyVVVVXik5BOhUJj4/DmgINYjkp8BAwcCqpWWlqanpaGrZGaMl9e2HduxNbFYYUpgG0kvkwDVHDo4qKur45EjJ6qqqlN+/83bx/vu3bsP7t9PTX1TXFRUUVHB4XB0dHQsraw6duro2qsXHsH/JDoSejIn9JxrMuMxwuPC+fNQanV1dWdiY/3kr8zw0cNHgGq9+/bB7zV56N2n75OEJ+iDxPAPDICt+H718lXC48cdOnaUEwMfP3qUkpICq+kX4I+RiSBIwxnj7ZWQ8Dj+bjxJPo9AIMjOzs7Ozr5969bXH6qrqxsZGxkbm5iYmBgaGRoaGurp6eno6sJO80PIxpvUVMC3IzQaza1/f3SV5PRz67d3zx7AWb7PnydaWVujsSSEzWb/uXAB7BsR5IdI4kr58gVkfrx7jx542EiOqpragIED8QvcaDIzM589ewYo6NKtm6aWlvwY2LpNG2sbmzepqVCCMVHRvn5+sB0SyM9zuDoUNTW1jnKTyKMErr1cN65fD3hLjfwcW1vbDh07JoCuyQg+EiQ/+fEQ6OLxNm3b2rdvj5GJIMgvsWTZMp8xXoWFhaT9hCUlJSUlJa9evqr/QxqNpqGhoaurq6unp6urq6Oro6urp6unq6Otra2j8/OFvwg1btqfQRaPt27d2sjICF0lObp6enbt2gEOynr+7JkndFtzpOloaWuv37C+dZs2aIUEEHt+vLKyMjMzE0qNRqPBzupFEBISExUNKzhM/uYieozwWLt6DZTahw8f7t275+zsLD8GZmVlAXb46eToiA2vSYWamlqrVq1evnyJVkiMgHGBsPnxhISEl0lJ8nC7nJKcDGsdQRD+WDyOIEijrp4bt2yeMnFSdXU1hT62SCQqLi4uLi5+/fr19/9VWVlZV1dXW0dHV1fXwMBAT19PX19fT19fT08PdqIPIj5gK6uwHpEqdO/eHTA/DtuiB4Fi+ozpmByXGGLPj6ckJwNWqFlZWeno6OBhQ2SY2tpawN4gBEEYGhrKyWTO+vRzc9u5fUdFRQWUYHREpFzlx18kvgBU6+KEE35IRxcnJ8yPSxIHB4c2bdokJUGuqAs+ErRp6xaZtw68eNzS0hInoCAI0jhatGixYtXKP+fNFwgEsrFHFRUVFRUVGRkZ3/z8S9W5nr6+kZGRkZGRoZHhl3/Q09fHogeykfzqFaCaswteIqmBc1fnbVu3Qql9+vSpoKBAV1cXjSUVdDoDTZAYYs+Pp6enA6p16IQr9BEZ5/q1a6WlpYCCQ+RmMmd9uFzugIEDTp86DSV47969jx8/6uvry4mBKSnJgGqdOzviV5tsOHbpfPDAAfRBkvgHBsz+YxagYHx8fFpampWVlQyblpWVVb+1Lgi+8jdPAkEQQFy6dftj9qzNGzeJRCIZ3s2vVecpyf+4J2QymXr6+iYmJs2aNTMxNTEzMzM1NdXV08PAkBZlpaWAPX8MDQ3Nzc3RVUpgYmpqYmKSnZ0NJZiWlob5cUSeEXt+/F3GO0C1Dh0wP47IONFRwJM5hwwZIp9ODvfwAMyPC4XCmKjoyb9NkRP3Un+0AreRt24mJnLV/p4qtGzZksvl8ng8tEJiOHftam1t/ebNGyhBkUgUEhS8as1qGTYtLCQUtlG+kbFx7z69MRoRBGkKIzw9RSJiyyYZT5H/ED6fn5uTk5uT8+D+/a8/5HK5ps2amZubW1paWlpZWlhYYMZcYqSlpQGqdejYAS2lEA4dOgDmx9PT0uRqwTSCfIPY8+Pfr9VqNHQ63a6dHR4zRIZ5l5GR+DwRULCri4vcpibNzc3bOzg8ffIESvBMbOyESRMZDNlf4iQSid6mv4VSa2vXFr/aJITBYLRs2RK2YSXyn/gF+C9asBBQ8Pq1a9nvJ5mYmsqkXQUFBRcvXIDV9Bk7FjsDIAjSdDxHehIi0ZbNm+UwRf49PB7vTWrqm9TUS//7ibKysoWlRYsWLVu0bNmyVUszMzN0SUzA5sfb2dujpRSinX27mGiw0WXpaeloKSLPSKB+HCw/3qxZMyUlJTxmiAwTHQ08mXO4/E3mrI/HCA/A/HhxcfGN69d79+kj877l5uYClhW3boP5cZLSum0bzI9LGNdevUybNXuflQUlKBQKQ4JDFi/5SybtOn70GJ/PBxTU1tYeNHgQxiGCICB4jhqpoamxcvmKmpoadOMbKioqEp8nfq37UVJSsraxadu2bTv7dm3t7PChHpCMt28B1dq1a4eWUgjY9xlvQWMJQSiHePPjnz9/BpyP18q2FR4wRIapqam5cA5yMqempqahkVFubq7cWmppZaWsrAx4FoqMiJSH/HhWZiagmrWNNX67yYm1tQ2aIGFoNJqfv9/K5SsANS9euDBh0kQ9mVvJXlZaGhsTA6s5xtuLxWJhHCIIAkXvPn0MDA3nzZ5TVFSEbvyEysrKZ0+fPnv6NCSYoNPpllZW9vb2nbt07tCxI56Wmwjgs56ampqhkRFaSiH09fXV1dVLSkpA1PLkOG+AIIS48+P5Hz8Cqtm0aIEHDJFhrl29Wl5eDihYXFzs6e6BxgLy7OnTd+/eyfzUmiy44lYajda8eXOMHHJiYWGBJkget/79D+4/8BHuBonP5x8NDZs9d46MGXX61Onq6mpAQVVVVXcPvCYiCAKMra1tUEjwX4sXw/ZIlGGEQuGXZiynTp7kcrmdHB2duzr3dHVVVVVFcxpBXm4elJSllSX6STksrawSHj8GkeLxeJ8/f9bQ0EBXEflEvB0YP4Lmx83McJIyIstER0WjCRQ4TJGRMr+PH/I+QEkZGBgoKChg2JCTZmbNmEwm+iBhGAyGj+9YWM2zZ84UFxfLkks8Hi/89GlYTc+RI/F0hCCIONDV09u7f39AYCCON2jE2f72rVtrV68Z6NZ//tx5t27ehG2rJfMIBILCwkIoNUtLK7SUclhZQR41wMdABKEclMqPm5vhAUNklbdv3ya9eIE+kJ/z587LfJfJD3lgdSgmpiYYM6SFwWAYGBigD5JnyNChWtrasPmFE8eOy5JFMVHRpaWlgIIKCgqjRo/C2EMQRFwP1XT6pCmT9x7YL/OrDMVEXV3drZs358+dN6Cf24b167EPcgMpyM8HfKNg3hyjl3rAZsk+fMhDSxH5vZSLVT0/Px/wwUZXVxcPGCKrxGDxOEWoqKi4dPGibO8j4KlbXx/Tr6RGH/Pj0oDNZo/xGgOrGRUZCduhS4oIBILjx47Bag4bPlxVTQ1jD0EQsWJnZxd2/NiEiRPZbDa60TjKysqiIiK9R4+ZMmny9WvXBAIBevITPn36BKhmaIjNx6mHoaEhoBrgcgQEoRzizY+XfC6BkpK9wVMI8pWampoL58+jD1QhKkLGW6wANmrQ19fHgCEzBgZ4gKSDx4gRsI1WKysrT588JRvmnD93vqCgAFCQxWJ5+Xhj1CEIIgGYTOa4CeNPhZ/u5+aG7VaawrOnTxf+uWD4kKGhISFVVVVoyA+BGsz4922hIZZNUA/Ykaqwq/cQhFqI95pdVgb27dLTx/w4IrNcuXy5oqICfaAKr1+/Tn6VjLfaDUFXD9f9kBodHTxA0kFBQWHkKOB2H6dPnYIdaCktwkJDYQX7D+ivo6ODUYcgiMQwMDRcvnJFSFiok7MzjUZDQxpNQUHBnl27hw8ZeuTw4crKSjTkG2Czmdh2j4ro6ekBnmQwP47IM+LOj4Mt9dXVxfw4IrNER0WhCdQiSnandJaVlgIuZVXDhgbkRk0dD5DUGDVmtKKiIuxDsgycmm7euPE+KwtQkMFgjPXzw3hDEETyWFlbb9m2Nez4sf4DBuBA7CZe4A7s2z9s8JAjhw/L/BygX3UGSkpZWRmjlIowmUwlJSWwiCrB/Dgiv4g7P14G9gyPSRZERklLS3v18hX6QC2uXrkiM61+vwG2NkdVFU/dpAavrVJERUXF3cMDVvP4seO1tbWUtiUkKBhWsEfPniYmOCgYQRCpYWlpuXT5sqiY6IDAQFzL0hTKy8sP7Nvv6e5x4fwFdOMLZaVg+Rac0kFdAI8dYAYPQSiHePPjFXD5IxVVFTxaiEyCxeNUhMfjnYuLk8ldqwTt8KiqporRQmZUVPAASRMvby8OhwMoWPTp09kzZ6hrSMLjxykpKYCCNBrNz98fIw1BEKmjq6c3acrk2Lizm7dtde3Vi8vloieNo6CgYPnSpYH+AS+TktANwJfiWDNBXQCPXW0trs9A5Bfx5scBz9eq+AyPyCI8Hu/yxUvoAxWJjoqWzZgE7V8Mm/tDwMHnc+miqaU1eMgQWM2joWGALZIkTEhwCKxg5y5drG2sMdIQBCHLszed7uzsvGbd2ktXr6xdv67/gAGws5rlh+RXryaOn7B18xY5b7dSV1cHJaWgoIBxhffzdXV89BOR32s0Vc7XHHyGR2SRy5cu4WROipKVmfkkIUH29osPmlljsVgYKmSGxcJGk1LGx3csbLvPDx8+XLp4kYpWvE5JefzoEaymX4A/xhiCICSEw+H0dHVdunzZxSuXDx05PHHyJPv27fGu6ZcQCoWnTp70GeOVmJgotybU1oHVI+I9IZXv58FOHXy4DB6CUA7x5sf5fD4Jv/MIQh5ktQZZToiMkMEpnQI+ZNUAnrpJDg5ikjr6+vr93NxgNcGrsCUD+Me2a2fXrl07jDEEQUj9NE6nt27TJnDcuL379125fm333j2Tp0zp6uKioaGB5jSE7OzsKRMn7dqxUygUyuHuA2YzWUy8aacqbLgHrjrMjyPy/Ggs3vM1XJ6FyWTg0UJkjNTU1JTkZPSButy+dauoqEhLS0uWdgr26YJOp2OckPqxnIHXVunj5+934fx5wK9eVmbm9WvXXHv1opAJ77Oybt28Cavpi53HEQShFFwu16FDB4cOHb78a25ubkpyctqbtDdv3rx586bo0ye06N/uXY+GhSUnJ69eu0be3isIhSK8J0RocA9cArl8z4QgXxBjfhy2/SUmWRDZIwaLxykOn8+PjYkJHDdOpq4KoAXFWINAcvAAkQHTZs16urpeu3oVUDM4KJha+fGw0DDYl3NWVlbOzs4YXQiCUBcjIyMjI6Peffp8+dfPnz+nvUl79y4jKyvrXca7dxkZJSUl6NJXnj554uczds26ta3btJGfvQa8b8d7QryfJ7DNDiLfiDH6GQwGjUYTiWBeafL5OCgAkSmqq6svX8LJnJQnNjrGPyBAll7gMRiQ1wXsYUdy8ACRBP/AgOvXrkHdMhEE8SY19V78PSdnJ0rsfkFBwcULF2A1sXgcQRAZQ0NDo5Njp06Onb7+pKysLPNdZk5Odl5uXnZ2dk5Odm5OrjwnzQsKCqZMmrx4yV/gjctIC5sN11ijtha/ZXg/j212EHlGvG+HmEwm1LssfJ+JyBiXLl6srKxEH6hOfn5+/N27Lt264X32j0/d+GqT3OC1lSR8KXa+e/cuoGbQkSNUyY+fOHYcNhSNjY179+mNcYUgiGyjqqra1q5tW7u29X9YWVmZl5ubn5//8ePH/C9/+5hfkJ//6dMneSg4q6urW7ZkaWFhoc/YsfIQA0y4xtO1eE9IWWoh68cxP47ILxTKj2OSBZEpoqOi0ATZIDIiUpby40pKSoBqFRUVGCFkBg8QefAPDIDNjye9ePH0ydP2Du1JvuNlZWUx0cDdxsb6+dJoNAwqBEHkECUlJStraytr629+LhKJiouLCwsLPxUWFhZ+Kvr0qbCw8NOnwk+fPhUWFH7+/BlwDZN0EYlEu3bs5FXzxk+cIPOHG7Dat6K8HL8+VL2fhzt2LDYb/UTkFvHmx1ksVnV1NYhUJT7DIzLE65SU1Nep6INs8Ojhw7zcXEMjI9nYHUXQ/HhpSSlGCJkpKytDE0hC6zZtHDo4PEl4AqgZHBRE/vx4+KnTUPeKX9DR0Rk4aBBGFIIgSH1oNJqWlpaWlhbRosX3/5XP5xcWFOQX/P3Xp8JPeXl5OdnZubm5NTU1VNzfQwcP0ui0cePHy/ZhVVZWhpLCdvbUpbQU7IELtlIKQaiFePPjXC4X6tm7rByf4RHZIQqLx2UIoVAYHRX9+7SpsrE7KioqgGplZZgfl5f7aaTpBAQGwubHHz18mJKc3LJVK9LuMo/HO336NKyml7c37JxhBEEQ2U8KMJkGhoYGhobf/6eC/PzsnJyc7Ozs99nv3mWkp6Xn5+dTYqcO7j+grKw8avRoGT5waupqcDftmG/B+3lCTU0N/UTk91IoVnUVVZWCggKY83Upnq8RGaGqqurKpcvogyxx9syZSVMmy0ZGhs1mKykpQTXHLy4uxvAgM8VFeIBIRIeOHW1b2756+QpQM+hI0IZNG0m7yzHR0aWgBWtqamrDPdwxlhAEQaDQ1dPT1dNzcHD4+pPy8vL0tLT0tPSMjIzU1NQ3qamk7Wy+fes2fX397j16yOrRAcxm8vn8z58/a2hoYMxTi5KSEsAvIObHEXlGvNkcVVWwb9fnz5/xaCGywcULF2DXkiNkuC+5dvVqPzc32dgdDQ0NqPz4hw8fMDzIzMePH9EEUuEfEDB39hxAwTu3b2e8zWhu0ZyEOysQCE4cOw6r6TlyJJfLxUBCEAQRHyoqKvbt29u3/7t/V21t7euU1y9fJr16+fJl0ktSVZcLhcKlfy05EhxMzutg04HNZubl5WF+nHLk5eZBRpQ65scR+YUuVnVVVbB1+vn4DI/ICjFR0WiC7BEVGSkz+6Kjqwt36s7H2CAzH/EFBslw6dbN0tISUFAkEoUEB5FzZy+cPw+bRlFUVBw5ehRGEYIgiCRhs9lt7dp6eXuvXrs2Nu5sbNzZxUv+6tuvr7q6Ohk+Ho/H+3PePKjKD7KhoakJqPYhLw/jmXJ8+AB51DTU8QUJIr+IOz8O9vYJa9wQ2eDVq1dv3rxBH2SPxOeJb9++lY19MTDQh5LKy83F2CAzefggRD78AgJgBa9euZpLym9iWGgYrODQ4cNUVVUxhBAEQaSInp7eoMGDV6xadfHK5dCjR3+fOtXe3p5Op0vxI71//37l8hUy6ba+vj6gWvb7bAxgypGdDXnU9A300VJEbhFvfxVtHW0oqeLi4rq6OhaLhccMoTSwxeNMJtPY2BhdbTQ5OTmA/dqiIiLnzp8nA7YYGBhCSWVmZopEIhqNhsFGQoqKinAWEwnp3af3gX37AJ92BAJBSHDwwkWLSLWbN2/cyMrMBBRksVjePj4YPwiCIOTB2sba2sZ6rJ9vcVHRzZs3r1+7/uzpU4FAIJWLTkR4+AhPTxlzWElJSU1NDWo8Y3p6GgYt5UhPSwdUMzQyQksRuUW8+XE9PT0oKaFQmJWVBbvoGEEkTGVl5ZXLkJM5XXu5rli1Co1tNIsWLLx29SqU2sULF6ZOn6agoEB1W0xMTaCkeDxebm4uvsUhJ2/T36IJJIRGo/n6+a0GPbdfOHd+/IQJunCtk5pOSHAIrOCAgQO1tbUxfhAEQUiIppaWu4eHu4fHl5k9cWfjUpKTJfwZ9uza7dy1q4GBgYx5a2BgAJUfT3uD+XHqkZ4GdtTodDrsigQEoRbiXegE++3KeJuBBwyhNBfOn+fxeICCQ4cPR1ebgvsID0C1ysrKixcuyoAtZmZmgGpv09Mx0sgJHhrSMmDQQD3QO6i6urpjYUfJs4MJjx/DZkYYDMZYP1+MHARBEJKjrq7uMWJEUEjwsZPMU8oKAAAgAElEQVQn3Ed4KCoqSmzTVVVVa1evkT1LAQt+c3JyqqqqMEopBI/HA1xxqKOry2Aw0FVEbhFvflwPOD+OlW4ItYFtrmJqaurg4ICuNgUHBwfTZs0ABaMiImTAFtNmzQA7orx8+RIjjZzgoSEtDAbDB7pVSGxMTElJCUl2ELx43LVXL1yngiAIQiEsLCzmzZ9/9vy5qdOnSWx506OHD8+fOy9jTpqZm0FJCYXCpKQkDE4q3cwnJQE2LDIza4aWIvKMePPjBgYGgEmW1ykpeMAQSl+90kGrNYcOH4auNh13d3dAtbS0tJfUv61UVFQELEVJSnyBYUZOkl7goSEvQ4YN1dTUBBTk8Xgnjh0nw669Tkl5/OgRoCCNRvP198OYQRAEoRxKSko+Y8dGn4mdv2CBZBo77Nuzp6amRpY8tLS0AlR7/uwZhiWFSHyeSNpYQhDKId78OJfLBbzOYaUbQmmio6IA1Vgs1sBBg9DVpjNw8CAOhwMoGBkRKQO2tGhhAyWVkpICOAQVgSI/P7+goAB9IC0cDmeMlxesZmRERGVlpdR3Dbx4vIuTk5UVPtEhCIJQFQaDMdx9eER01PSZM1RUVMS6rYKCglMnT8qSe1bWoPnxp5gfpxLPnj4FVLPEuylEvqGLewPNLZpDSVVUVLx79w6PGUJFKioqrl29BijYo2dPdXV1NLbpqKio9O7TG1Dw+rVrZUBDcqSITYsWUFI1NTUvsIScfMAW8CLiwMNzBGyaoKKiIvzUaenu1PusrFs3b8Jq+gX4Y7QgCIJQHSaT6eXtHR4V2X/AALFuKDQ4pKysTGZ8MzExUVBQgFJLSkqqqKjAaKQEVVVViYmg9eNWlugqIs+IPT9ubt4cUA3fZyIU5cI54Mmcw7C5ChzDQVus1NTUnD17luqetGnTBlDt/r17GGZkAw8K+VFUVPQcNRJW8+SJE7AXo18lLDRMKBQCCrZr187Ozg6jBUEQRDZQV1dfunzZ1u3btLS1xbSJioqKqMhIWTLN2sYaSorP59+/dx/jkBI8fPCgrq4OSo3D4Zibm6OriDxDpfpxgiDu38eTNUJJYJurmJiYOHTogK5C0bpNG9i1+bCDWKVCK1tbJpMJdurGVCzJEAqFjx5i/TgFGD16tKKiIqBgSUmJFE9QBQUFFy9cgNXE4nEEQRDZo4uT0/GTJzo5OopJPzI8AnCqodSxa9cOUO3undsYgZTg7p27kE9/rVoBPv0hCBURe368RYuWgGpPEhJk6UqGyAkvEl9kZGQACuJkTnDcPTwA1bKzsx8+fEhpQzgcjg1cC/L09PTc3FwMM/Lw9MmT8vJy9IH8qKqpDXMfDqt57OhRaY0EOHHsOGChE0EQ1jY2XZycME4QBEFkDzU1te07d3j5eItDvLCw8NrVqzLjFWx+/M7tOzI2wlQmqaurg21Y187eHl1F5Bzx91dpbq6srAylVllZCTuCAEEkAPhkzkGDB6OrsPTr7wZbpBlF/SmdHTt2AlS7cvkyhhl5uIyHgzp4+/iw2WzYpECcNHpAlZWVxUQDl677+fthhCAIgsgqNBpt+owZs+bMptFo8A9okVEyY5SdnR2dDpbYqaqqAp8UgoBz984d2E7xdu2wWx0i74g9P06j0VrZ2gIKXr1yFQ8bQiHKysquX4OczNm9Rw+czAmOoqJiPzc3QMH4u3cLCwsp7UlHR8yPyyYCgeDm9RvoA1XQ0tIaNAT4nWhoSChsE/CGEH7qdHV1NaCgqampa69eGCEIgiCyzchRo2bPnQMum5iYWFRUJBsWKSsrW1pCTla8cP4CBh7JgW1Yx2Qy27Rti64icg5dAtuAnfN248YNbLGCUIjz587BrlDDyZxiAnZKJ5/Pj42OobQhbdu2Baypf5v+NjU1FcOMDNy+dausrAx9oBBjfX1hO0Lm5eZevnRJkrvA4/FOnz4Nq+njO1YcFYUIgiBlZWW3bt48uP/AqhUrlyxevH7tuv179128cKFYVtKplGOEp2dAYCCsplAovH7tusxYBNtt7OGDBx/y8jDwSEthYWH83XhAwTZt2igpKaGxiJwjifx4W9CVGqUlJQ8ePMAjh1AF2EloJiYmHTp2RFfFgbWNtW1ryMUusTExlH6Zx2KxYMciydI6VkoTTf35sfKGgYFB3359YTVDg0MkeimMji4tKQEU1NXVHTBwIMYGgiCwPH/+fO7sOQP6uc2fO+/woUNxZ89evnQ5Oioq6MiRZUuWDuw/INA/4PYtnF4oBSZNmdy5SxdYTdg1vtKlq0tXQDWhUBgRHoFRR1qiIiNhZ8k4g8YPglAUSeTH7e3tORwOoCDVqzIRObrJfvYsMzMTUHDoMCweFyOwUzoLCwvv3Kb2E5RLNxdAtcuXLlVVVWGYSZfc3NzHjx6hD5TD198fsLUoQRAZGRkS6y4qEAhOHDsOq+nl7Q1bU48giJxTWVn516LFkydMvHP79r8lnkQiUfKrV/PmzAnw88/OzkbTJMySZUvV1NQABV8mJdXW1sqGOa3btFED7cB59swZHo+HUUdC6urqwBNizl0xP44gEsmPs9lse9BhuPfi46ne2BeRE2DrNFks1sDBg9BV8dG7Tx8VFRVAwSiKV0y7uLgAZqCqqqrOxMRimEmXUydPikQi9IFymJmZ9ejZE1Yz6PARyXz4C+fP5+fnAwqqqasPcx+OUYEgCBR5ubn+Y30bPislJTk5wNfv9q1baJ0k0dTUnPL7b4CCdXV1ya9eyYY5NBrNCbTFSllZWWQElpCTkbNnzhQXFwMKGhoZmZubo7EIQpfMZmAXQ/H5/OgoXKePkJ2y0tIb1yG72nXr3l1DQwONFR8cDgd2wf7jR48oXV6kqqYG28/nxPHjOEBCipSWluIrCuriHxAA22779evXDyXSsO5oaBis4MhRI/+vvfsMiyJZ4wU+MwxhYAiCAiKSowkUFcwREyiCERAFjGvOOeesu6Y1J0wooICuOSMqqICKgChRBSQPDHHgfuBc7153dRVrerp7/r8P5znPOVjd/VZNd3V1Vb0qKipoEgBAqsc+dfKUn+2wlZSULFqwkE0bdDDCIDc3I2NjggXGxsayJji9nXuTLfB0wCmyabTg10kkEuJb5PXqjWznABwOdePjHQlvFhZ0/gLW+wDNXQ6/THbJHjJzUsBj6BCCI1C1tbVM/5hHtqudnZ1NNtk6/JTAs+fw6GQuK2sr4luvHjtyVNqnfffOHbL7jKmqqg4fMQLtAQBIWbN6zcd6pSKUSCSrV65KTk5GDCnD4/E8PT0JFsia+eMcDsepQwctolus5OXlYVYi3YSHhWVlZZEts1///ggsAIey8XETExOySzaKioouIsMY0FtICMkmamho2K59e0RV2oyNje2J7gd1OSyc0Tsb9ujZk+w8zSOHj2AKuUwUFxefO3sWcWA0P39/sgW+ePEiJiZGqud84vgJsgW6e3iQ3QgLAOTZo4hHv5Itpry8fP3adQgjlfr060swt1lGRiZrIqOgoNDb2ZlsmUePHC0pKUGro4ny8vKD+w+QLdPCwsLc3ByxBeBQNj7O4XCI36xPBQRgvQ/Q1vNnz9PT0ggWiMyclCGbpbOoqOjmjZvMjYaamlq37t0JFvghM5Pp27Iz1NEjR/CGw3St7Fq1btOGbJlSnUIeHRVFdmqekpKS1yhvtAQAIOX4sV+9B8a/fn3/3n1EksquqUPbtqRK+/jhA5uC069/P7IFFhUWHjl8GK2OJk6dDMjNzSXdZjB5HOB/qBsf70V6P6zPnz8Hnj2HKgR6IrsYjc/nuw4aiKhSo0fPHmT3eQ9meHKbgaTb3rEjR8rKytDSqJSdnR10HkmW2MDX349sgY8jIxMSEqR0tsdJb5E5wMVFR0cHzQAAiMjMzIyNIbD99MUQLGumlENbB1JFlZeXEx9wlKEWLVuamZmRLfP8ucCM9HS0OpnLyckJOEk4oQufz+/vMgCxBahD3fi4iYmJuQXhhRsnjh8XiUSoRaCbwsLCu3fuECywW3dk5qQO8a8Rr169epuUxNyAtG3XrmnTpgQLzMvLO3TgIFoalXZu38HofX7gC0dHR9tmzciWefzoMWmcasKbN1FPnxIsUEFBwWfMaLQBACAl4uFDIuVEPX2KZc1Usra2Jlhafl4+m4IzdPgwsgVWVVVt3LABrU7mtm7eQnyCUfcePTDtAOALHpUHc3UlPAlRJBId+HM/ahHoJjwsrKqqimCBg93dEVUqeXh48Hgkb49BF4KYHRCie85wOJxzZ8++f/ceLY0ajyMj79y+jTiwhh/pKeT37t4lm0KzDvHJ471692rSpAkaAACQEhcbS6Scqqoq6S3EgX8i+ywoK2fVosb+AwYIhUKyZT6LfhYeFoaGJ0N379y5f+8e8WKHjRiO2AJ8Qen4uIuri5KSEtkyg4OCEhMTUZHMVVpaKhaLWXZRl0IukuwCIjMn5RobGLR3dCRY4LWrV0tLS5kbENdBA8lm6ayurt6yaRNaGgUqKiq2bdmKOLBJ127dzIhmUqqpqSE+hTw9Le3e3bsEC+RyuaN9fVH7AEAQwU/1mRkZiCdlGmhrEyytjF2vogKBYICrC/Fi/9j5e05ODtqeTBQXFW3dvIV4sVZWVnZ2dggvwBeUjo9raGr26NmDbJkSiWTzxo21tbWoSwbJzs4+fuzYpPETunfp2qt7j57dunft1Hn4kKGbNmy8d/duTU0No68uOioqg2gX2W2wG9oM9TyGeJDseZeV/XXlCnOjoa6u7jqQ8AKgFy9enDt7Fi1N2vbu3pOBl3bW8fXzJVvgjevXP338SLDAkydOkn2ad+rUycLCAlUPAARlZWWRKkpUjD0/qaOsrEywtPLycpbFZ+TIkXw+n2yZxcXFq1euQtuTiXVr10ljl/yRXp6ILcDf8Sg+nttg8ttEvH71+lRAAOqSEXKys5cvXTpksPu+PXtjYmK+dEcqKyvT09NDgoMXzJs/bMjQsFAGL+AKCSaZoofP5xMfl4Qf0blLF11dXYIFBgcFMzognt5eZPec4XA4+/bsRcIfqXrx/Pn5wEDEgX16OzsbGhoSLLC6uvrkiROkSvv8+fPVv/4ie8ljSH8SAAA5V1VVRXAzX/aNsdJZdXU1wdJ4PAWWxcegSZM+ffsQLzY6KgqjLtQLvXSJ7IK8Ok0MDfv174/wAvx/jwOKj9fGoY2VlRXxYg/8uT8lJQXVSWe1tbXHjx0bPnTY9WvXv9+n+ZCZuW7NmgXz5pWUlDDuMgsKCsg+wLp266ZNdAkh/HBfmec2eDDBAt+/excTE8PcgDRp0oT4AqDy8vLly5aTfcmBL0Qi0aoVK5m+Ige+dYMinqkyPCyc1Oyk0wGnyCbhaN2mTctWrVDvAEAQ2YyayM9J6QtXPsmMmsoqyuwLka+fH/F5LRwOZ9+evbGEdu2HH/H27dvtW7dJo+QxvmOk0UIAmP2GRf0hR40eTbzMysrKFcuWk30ZA4KKioqmTZm6b8/eH59bce/uvXF+/sVFRcy60vDQMLKDfcjMKUODBruRXZwYEsTsLJ2+/v5cLpdsmW/i43/fsRONTRpWrVhJcOU40I2LqyvZNS6VlZVE5oUVFxdfDAkhe7FjfMegxgGArBqJhGBphYWFCCllyG4cJ1ARsC9ERsbGvXr3Jl5sdXX1koWL8vPy0AgpIBKJFs5fII21KXr6+i6urogwwFdkMD7e27m3gYEB8WKTEhOlkbUASFRNkq/P6OioqJ/9h6mpqXNmza6srGTQxV68SDIzp0GTJu0dkZlTZho1atSpcyeCBd6+dZvRr0+WlpZdu3UlXuz5wMDbt26hvZEVcPLkwwcPEAcW4/P53j6jCD/CgkN+/bP0+cBAglsWcDgcaxtrpw4dUOMAQGefPn1CECjz6tUrgqVp67Bzqe74CeOJ70LO4XByc3MXLVyI1Z/SVltbu2LZ8g+ZmdIofOy4sQoKCggywFdkMD7O4/G8RnlLo+RLFy9euXwFlUorEQ8fTpowod5dxpcvXx47epQpF/v0yVOyzzBk5pQ5jyFDCJZWVVUVdimU0QEZN2GCNNbirV295u3bt2hvpDyOjNy3Zy/iwHqD3d0bNGhAsMCysrIzZ878SgkVFRWB5whveT/G1xd1DQA09y45GUGgrp/zKJJgaY0aNWJllIyMjcnuFflFbEzsmlWr0Q6lavvWbY8iIqRRsrmF+cBBgxBhgH+SzZZDboMH6+nrS6PkTRs2kP2eDL/i3Nmz8+fOE4vFv1LI6YBT2dnZjLjekGCSCRj5fP5AZOaUNUcnJ4MmTUg2EtLbDlDM0tKytzP51ZpisXju7DlYrUlEamrq0sVLJESXjQM9KSsrj/TyJFvmhcDzpaWl9f7nF0NCioiukjEyNu7RsyfqGgBo7vPnz0x5YWG6nOxsgltga2lpKSsrszVW4ydOEAqF0ij52tWr+/f9idYoJadPnTofGCilwqfPmEF8w0wAdpDN+LiiouL4CeOlUXJFRcX8OXOxwE3mampqtm7esmPb9l8foykvL7/IhCHF/Ly8B/fvEyywS9eu2jo6aEsy5050C/iPHz5EPnrE6IBMmDRJGqs1s7Oy5s6Zi/RWv3ojys+fPXMWE5MbQ/0MHTaM7KuvSCQKunChfv9WIpGcDjhF9gJ9Ro/GWxwAMALTO3hMEXQhiGDucVMzMxbHSktLi3g27y+OHjlyPvA8GiRx165e3f3HLikV7tShg6OTE4IM8K9klrLWxdXVTDpPo/z8/NkzZhYXF6N2ZaW4qGj2jJkXzhN7Xt6/d4/+Vx0aGko4M6cHMnPSwkC3QYqKimS79YwOiKGh4ZChQ6VRcvzr1wvmzcfE53orLS2dOX3Gxw8fEAr5oaamNmz4cLJlnj19pn5fqq7+9RfZ6ZN6enoDXAaglgGAEa79dRVBkDaRSBRMNN29GavHxzkcjpe3t5GxsZQK37516+XwcDRLgu7eubNm1WqCX4D+TlFRcdac2QgywLfIbHycy+VOmjxZSoWnpKTMmjGDbHoo+EFv4uNHj/J5/PgxwTLfJb+j/weP0IuXCJZmYGDg6OiI5kQHWlpa3Xv0IFhg5KNHTF+BO3b8OA0NDWmU/DgycuXyFWh19VBZWTl31uykxESEQt6M9PIUCAQEC8zPz79Ur1zTJ4+fIPxWP8ob+aMAgCliYmLeJiUhDlJ15NBhkUhEsMDmLZqzO2KKiooLFi2U0kqs2tra9WvX3bxxAy2T1EvisiVLpZf7dIyvr7HUPpYAsABPhsfu2q2ro5O0RgBfv3o9Z9bsyspK1DGVQoJDJo6fkJWVRbzkvNxcOl/448jIjx8/EixwEDJz0onHEA+CpUkkkovBzN6FXENDY5x09sjicDg3rl9fu3oNWt1PqaysnD9n7osXLxAKOaSpqTnYnfB6o1MBp352Jce9u3dTU1MJnoOWlhbx6wIAkJ7a2toD+w8gDtKTlJhEfFPm1q1bsz5uDg4OA1xcpFS4RCJZsWz5X1f+Qvv8RQ/u318wb35VVZWUyjcxMfH190OcAb6DJ9vDz50/X0lJSUqFP3/2bPbMWeXl5ahmCojF4lUrVm7asEFK3yQKieb7Ii6E6HAnn88fhKTSdNK6TRsTExOCBYaGhjJ9F5Ghw4ZZWVtLqfDwsLA1q1bX1tai7f2IysrKeXPmkF21A8ziNcqbbG8qOyvrSvjln/onx48dJ3tRw0eOYHHONABgpQf375NNRwRfVFRUrFi2jOzUWj19/cYGBvIQvRkzZzRo0EBKhUskkjWrVtVv5RnUuXnjxqIFC6U3uZPL5S5cvEgaGaQA2ETG4+NNmzb1HjVKeuVHR0VNnzqttLQUNS1VMTExozy9/rpyRXqHUFMT0vbyc3NzIx4+JFhg5y5dkJmTbtyJTiHPy829d/cusx8ePN78hQt4PGk9RC6Hh69cvgJ7kf8nsVg8e8bMJ4+fIBTyrFGjRsSnhp04fvzHv1E9i46Of/2a6EOf/L7qAAAUWL92XS69l70y1OaNG1NSUsiW2aVLFzmJnoam5qIli6VXfk1Nzcb1G04cP46GWg8hQcErli2X3rYqHA5nxMiR9nKwVALgF/Fkfga+/n4GTZpIr/y42Ngpk37Lz8tDZUtDdXX17j92TZ44iezuIl/hcrn6jfVpG4SwS4Qzc7ojMyf9uLi6qqioECww6MIFpsekRYsW7h4e0iv/2tWr8+bMrV+eQDlRUFAweeKk6OhohAJGjxlNdlpQRkbGjes/uqMo8cnj7h4e6urqqFYAYOKjee6s2VjBTNapgIDLP7mq6Ud0695NfmLYtVs3qW7gWVtbu3f3ns0bN0optyRb7dm9e9PGjVKdEmRuYT5l2lSEGuA/yX58XFlZefmK5dKbhMjhcBISEvx9/VLev0d9kxX/Ot7XZ3TAyZPSfgqamJhIKRkgka4A2dVkBgYGjk5OaF10IxQKezs7Eyzw+bPnaWlpTA/L1OnTGjduLL3yH0VE/DZxUlFREVrgP3388GHC2HEJCQkIBXA4HIMmTcjeozgczoljx36ol/XmzdMnJFcwKCkpeXp7oU4BgKESEhKWLl6CUUJSrl+7tvuPXcSL1dHRaePgIFeRnDV7tqGhoVQPERwUPG/OHLFYjHb7nyoqKpYuXkI8t/k/+1Sr165VVFREwAH+E48OJ2HfuvUIz5FSPURWVtb4seOeYHtWQkpLSzdv2jTO3z85OZmCw3Xv2YO2oYh8FEk2H+kgN2TmpCmyW6zU1tYGXwhiekwEAsHipUu4XK70DhH/+jU+cP5TbGzsWD//jIwMhAK+GOPnS3a2QXJy8o9spHuC9Kud60BXHWwyBgBM9vDBg6WLl2CbuF935/bt1StXSSMnzQAXFwUFBbkKpkAgWLV2jbSHSiMeRviP8U1n/jQgqfr06dP4seNu3rgh7QNNmTbV3NwcAQf4ETyanMfkKVNMTU2leoiSkpLZM2cd/7HJUPAd169dHz50WPCFIGqmRfD5/IEDB9I2GiHBwYQv1g2ZOWmqefPmZDNSXrl8mQWbh7Rr337Y8GFSPcSHzMxx/mPJ7vLPaGGhYVN/m1xQUIBQwN+Zmpp27UZ4qfixo0e//wcZ6el379wheEQFBYVRPj6oTQBgutu3bi2cvwDbxP1aV/nKsiVLpbEvM5fLHSSX71zNmzefMWumtI+Smprq7+uHXLXfEvX0qe/oMUmJidI+UG9n5xEjRyLgAD+ILuPjioqKq9euUVZWlupRJBLJvj17F8ybj4yd9fMmPv63iZOWL12aR2Hamb79+kp1h/pfkZOT8ygigmCBnTp3xqQ5OvMgOoVcJBJdv3adBWGZOn26mZmZVA9RWlo6b87cA/v3S2MCEYNUVVVt3rRp3Zo1VVVV+D3CP/n6+5Et8PWr11FPn37nD06eOEH2Y3lvZ2faPvQBAH7Kg/v3J4wbl5OTg1DUQ8DJk2tWrZJS0sJOnTo1NTKSz8AOHTasX//+0j5KSUnJ/Lnzft+xU6ppJxmnpqbmwP79M6fPKCoslPaxzC3Mly5fhpgD/DgefU7F0spqzry5FBzo3t273iM9nz97jur/cR8/fFi6eIm/r9+L55TGTSgU/jZlCm3DEnYplOzCSWTmpLm+/fqpqakRLDA4KIgFYVFSUlol/Q+cNTU1Rw4dnjp5stzmW/744cN4/7Es2JYHpMfGxsaJdAaL70wh//z5819X/iJ4LC6XO9p3DOoRAFgjMSHRb4zvs2fPEIofJ5FI1q9bt/uPXdKbFTFqzGh5jvCiJYstLCykfZTa2tozp0+P9fPLSE9Hq+ZwOFlZWZMmTDxy6DAFOy8JhcJNW7aoqKgg7AA/jkersxnk5ubi6kLNvWnq5Mm7/9hVWVmJRvB9eXl5O7fvGDl8xM0bN6ifuTl95oyGDRvSMzK1tbWhoaEEC2zcuLFThw5ocnQmEAj69u9HsMA38fEJb96wIDKWlpbUfOB8Fv1slJf3/Xv35K3tXbl8efQoH2TjhP/kO9af+I/uZVzcv/5fp0+dIruUoVPnztglEwDY9jKVmztt8pQ9u3djO/IfkZubO2nCxNCLl6R3iDYODvb29vIcZGVl5S3bt2lra1NwrMSERB/vUadPnZLzNaAhwSGjPL3iYmMpOBafz1+7fp20c7ECsA+Pbic0f+FCCj5mcjicmpqagJMnvUd6PouORjv4V1lZWVs3b/FwG3z2zBmZfEhw7tOHzskqH0VEZCMzp/zxGDKEbIHsmELOofADZ35+/vy581atWFlSUiIPTa6wsHDBvPmrV66Sk+uFX2Rvb0/8tf9fp5AXFxdfCrlI9kC+fr6oQQBgn5qampPHT4wZ5fOtz41QJyIiwsfLW6pR4nK506ZPQ6gbN268dft2auYXl5eX/7Hz9/H+Y1NSUuQw1B8/fJj62+RNGzZQ1pOft2A+Zt0B1APtxseVlZW37thOzcdMDoeTkZExdfKUNatWy+2C/X+VkpKyZtWqoe4eF86fl1VWGdtmzWi+YVZIEOHMnIMGY3ycASwsLFq2bEmwwOvXrrNm3HPBokW2trbUHOuvK1dGDhvOjg3cvyM8LGzksOH37t7FTw9+HPFdyB9FPHqblPTV/3g+MFAsFhM8ShsHhxZE764AALSSnJw8Ydz49WvXFhUVIRpfKS8v37p5y9xZs6Wdfty5j7Nts2YIOIfDada82ao1q3k8ikaEXr165ePlvfuPXWQ7D3RWUVFxYP9+zxEjoymckTnG19dt8GA0b4B64NHwnPT19bds30bZZkm1tbWXw8OHegw5duSonGcYl0gkd27fnjp5iteIkZfDL8swmYaxicn2nTukvZ3xr8jJzo6MjCRYYKfOnZCZkynciU4hLy8vv3L5Mjsio6SktGnrFspacm5u7vKlS6dOnpKelsbKt+iJ48evXb2mUPoJfIBlnDp0sLGxIdtTOnb02FevfIHnAgm/0WHyOACwXW1tbeilUA+3wYcPHnCePwAAACAASURBVCorK0NA6jx98tTb0+vC+fPS3oJDKBTOmDULAf+iW/fu02fOoOxw1dXVASdPDh8y9Mrly6zfbuXG9RvDhw47cugwlUNMffv1/W3KZDRsgPrh0fO0mjdvvnzlCi6XS9kRxWLxn/v2DfMYcuH8ebKbaTJCTnb24YOH3Ae5LVqwMDoqSraPq6ZNm+7eu6dBgwZ0jtili5fI7iE42B2ZORmjt3NvDQ0NggWyKeOirq7upi2bqcwGEx0V5TXSc+vmLdKecESZ3Nzc9WvXjhnlExsTi58b1A/xKeR3bt/++4eoiyEhRUS/3NjY2Dg6OqLiAEAelJaWHjxwwMNtcMDJk6WlpfIcioyMjPlz502fOvVDZiYFh/ttymRMSPrKSE9P/3FjKe7orl65ytvT6/69+6wMaeSjR2N8fJYtWUJ2L9b/1KVr1+UrV6JJA9Qbj7Zn1rNXr2kzplN80JycnK2btwwZ7C7DfUWoVFJScunixd8mTnIbOOjggQM5OTkyPyUbG5sDhw81atSIznGrqakJI5qZU19fH3uEMYiSkpKLqyvBAlNTU58/e86a+LRo2XL5ypWUrdbkcDjV1dUXzp8f6u5xcP8BkUjE3NAVFxX9uXffMI8hoZdCkcULfkX3Hj3MzMzIPviOHzte998lEsnpU6fJnjAmjwOAvCkoKNj9xy4314F7du/Ozc2Vt8v/8OHD2tVrPIePoCzpetu2bYcMHYqG908TJk4cMXIkxQd9/+7d/Llzx/r5sWmUPCIiYsK48bNmzExMSKT40O0dHddv3KCgoID2DFBvfDqfnJe3t7hUfOjgQYqPWzdKfnD/gcHu7kOGDdXV1WVZrYtEokcREXdu33kUESGTxJvf0q59+01bNquqqsrqBCoqKsrKysrE4vKKCs63J9HHxsaS/Zbg6OSUSjRdiYqKikBVVSAQ0HmPGmrU1NSUlpaWicVl5eU15AYcW9m1OnOa5PDQ2TNnGjTQ+s4f8BQUVFVV1dTUBAIBlWtr6qdnr57TZ87YuX0HlQctLS09fOjQ2TNnPIYO8fL2pvkalK/k5eWdCggICQqmeLW1uro6wS8KOdk5Ke/f16cvoqioqqoqEAhkeP9nn9G+Y1YuX0GwwGtXrw50G6SpoREZGUl2SpSxiUmPnj1RZYwgFovLysrEYnE1Y1db5n4mNhApkUjqd9OjBS5XRVlZoKqqqqqqpKSEti0rJSUlJ4+fOHPqdJeuXQe7D3Z0cmL9Jb+Mizt96vT9e/eonAqgqam5YvUqtLdvmTVndlmZOPRSKMXHff3q9fy5c41NTEaNGtW3fz+G3oskEsmN69cDTpxMTk6WyQnY29tv2bZVUVERLZl9cnKyGdzTYFoPhEv/jZ9+37nzDOlpSj/x0s7nO3XoMHDQwM5dujD9c1xmZubD+w8ePLgfGxMrw73Fv8XF1WXRkiV8PqXfbIqLiiIjI2NexLx79y7l/XtGzzz9V0Kh0Mzc3MzMzM7evmOnjpqamqx/hNTW1sbFxUU9eZqUlJTy/v3Hjx9ZNg+Xz+cbGRmZmZvb2Ng4dexgYWFB21M9uP/A4UOHZHJoJSUl5z7OQ4cNo38KplcvX54PPH/71i3qt/YyNDScMWvmvDlz6RMNFRUVExMTUzOz5i2ad+jYsUmTJugW11tNTc1QjyEfP3yg/6kuXb7MdeBAVBk9paSkRD56FP86PiXlfXpauhxuQigPtLW1Tc1MTU3N2ji0cXRyUlNTk4erLi4q6tPbmW5nZWBg4OLq2qdvn6ZGRuwL+LWr10IvXXr79i3VQx5c7qYtm7t264Yf+/ffodauXnM5PFxWJ6ChoeHi6uru4W5kbMyUoH36+PFiyMWw0ND8/HxZnUPr1q237dyBKSZf3W3ep6SkpaYWFhaWl5WLxeKqakp7LyFBwazfYZ8UnYYNTU1NzczNWrdu7ejkJNuWzGVEtW3euDE4KFi259CgQYNevXv36NWzTZs29J+8+f9uDcXF0VFRUU+jnj59Ss22bvWgqKg4Y9bMocOGUXnQjPT0QwcPyWRMSlb4fH637t3GjhtvZm7GygusqKgIPHvuwoULFO/1JltW1tY+o0c793Gm5+nt2Lb93NmzMjwBaxvrAS4uffv109LSolVkCgsLr129ejksPCkpSSYnYGxismff3oL8fB/vUbRt3q3s7Eb5+HTt1hV9x3r2zoNDNm3YQPOT1NPXD74YghXBNHT71u2TJ068iY9HKOSKsrJyr969/MeNMzQ0ZPeV0nN8/AvbZs369OnTrXs3A4Z/Ki4qKnr44MHNGzejnj6V1QwtP3//ib9Nwq/7R2zZtDnowgUZngCXy23ZqlW//v169+6tQdepXcVFRbdu3b554/qL5y9qampkeCZOTk6btm7BkvE6cbFxVy5ffhwZmSVPowFsIhAInPv28fPza2xgIJv7D1M+a8h8kOULbW3tbt27O3VwatuuHT2nV+Tn57+Mi4uNjY15EZOYkEDzybN6+vobNm5s1py6OZ61tbWHDx46dvQoDSfRU0BBQcHL23vS5N9YNhgRExOzctlyuX0W2tvbr167RldPj4bntn3r1sBzgbI9Bz6f7+jk2L17j85du8h235WCgoKH9x/cvXvnyeMnMrwFmZqa7tm3V1tH521SEp3Hx//X9e/QYcWqlczaMIcmqqur3Qe5ff78mc4nOXvunOEjRqCyaCU3N3fl8hXRUVEIhdzi8/n+48b6+fszaFbQz6L5+PgXRsbGnTp1curYwd7enimjYBKJ5PWr19HRUZERj16/fi3bAcSOnTpt37kDP+ofJ9vl+3+/C7Vt27ZT586du3SW1WDZVz59+vTw/oOIhw+jo6PpMJLQo2fPtevXYYYBh8NJTEzcsXVbTEwMQsECioqK4yaMHz1mDPU9EC6Dpv3v27P3+LFjtOo4Nm/RvE0bhxatWrZs2VJDQ0NWZ1JSUvI2KSkpKSnhTUJcXBxt54n/U+cuXZYuX0blvM6qqqolixZTlgeGttq2bbtl+zaBQMCOywkPC9u4foN8fvD4Qltbe/vOHTa2tjQ8t+3btgWePUeHM+HxeM1btHB0dGzbvl3Lli2p6VBKJJKXL18+i4p++vTJy7iXsn1L5HA4FhYWu/ftrbvxMmJ8nMPh6Ovr79q7p2nTpugy/qyzp8/s3EHfcQEtLa1L4WGY90QrycnJs6bPoPlnFaBGt+7d121YT/Hmh5Rhyvj43989LSws7Ozt7eztbG1taTJi+EVubm7Cmzfx8fHxr17HxcWJxWI6nJWNjc2+A/tZ88pDmcMHDx06eJA+I0Wmpqbt2rdr3aZNGwcHivcLLSoqev7s2Yvnz6Ojot/TaRtoF1fXJcuW8ng8NNcL58/v3L5DzocC2Ecmn3+4zNoW5+jhI/v//JOGJ8blco2Mja2trcwtLCwsLc3MzPT19aX0uaOwsDA9LT09PS0jPSM1NeVt0ttPnz4xbnsjNTW1mbNmDXQbRPFxlyxadOvmLdxuOBxOe0fHnX/8zoJn6u1bt5YuXiLzMUc60NTUPHD4kDEt9+zbv+/Po0eO0OqUVFRUbJs1s21ma2Nja2ll2bRpU1JDADU1NZkZGUlJSfHx8W/i3yS8eUNx1s3vaNmy5bYd27+sV2XK+DiHw9HX1z9y7Ki2jg5+6T+lvLzcbeCgosJCep7epN9+8/X3QzXRx6ePH8f6+ctwH1Wgm169e62j/TZN9cO48fGv1CUZsrC0MDc3NzQ0NGjSxMDAgLIP/znZ2RkZmZmZGWmpae/evXuXnFxQUEC3EDUxNDx4+JC2tjZ+yPVwOTx8w7r1dBtz5HK5TY2MbG1trW2srW1sTE1NiddvXl5eakpKYmJiYkJiQkJCeloaDUda/MeNnTBxIloph8MJOHFy965diAMr9e3Xd9WaNZTeYRg3rkrPO/U/KSoqNjYwMDQ0bNSokU5DHW1tbR0dHQ1NTTU1NXV1daFQqPh/felnVFVVVVVVVVdXi8Xi4qKi4uJikUgkEpXk5ebm5GTnZOfUKSkpYXpDt7O3W7FyJfW76QUHBW3euAk3mi8mTJroP3Yss9/kP30a5elVWlqK2qxjYWFx7OQJek71Onv6zO87d9L2ocPn8w0NDZsaGTVurK+rp6enp9+ggZaGhqaGpsaXO3bd96Sampq6e7Wo7h4tEhUUFORk5+R8zsn6lJWWlpqRnlFZWUnDa+zWvdvqtWv/PleXQePjHA7Hyclp564/8DP/WbSdW6CmpnYpPEwoFKKOaKK2tna8/9hXr14hFPB3c+fPozhLEDWYPj7+TzweT1dXV19fX6ehjo6Ojra2jo6OjoamhkCgqiZUU1NTUxUIVAQCPp+voKBQ959f/q1EIql7Gy0vLy8vL68orygpKRGViEpEIpFIVFhQWFhYWFCQn5Odk5WVlZ+fT/MNPDkcjp6+/p/7/6TbLHtmiXr6dNGChTQffBAKhU2NjAwNDRvpNmrYsGHDho20tLQ0NDXU1dXVhUIlZWVFRcUvTb2ukVdWVIhKSur68EVFRZ9zPud8zsnJzvnw4UN6WhrN3yv5fP6iJYtdXF3RPjkczoP79+fPnYdMmCy2eOmSQW5ulB2Oy8TGxIg79U91ZWpra+XkVy0QCCZMnDjSy5P6vYREIpGH22CRSIS7zBfKysrng4N0dXWZewlLFy+5eeMGqvLvZs2ZPWLkSHqe243rN9asWkXPseMfemRyuVwul6GLFYYNHz577pyv7r3MGh/ncDibt25Fus6fVVpa6uY6kIa9Jp8xo6dMnYoKoo/L4eFrVq1GHOAr6urqwZcuqqurs+y62Dc+Xg8KCgq1tbXsW4Wpq6u778D+JgxPbUoH7969mz1zVjbzMzzxeDwWtHOhULhh08Z27dujZXI4HLFYPNTdAyve2E1TSyv4YghleR8ZubVCu/bt9x86qKevz44qr6mpkZPB8c6dO589H+jp7SWTVD+hly5hcPwrFRUVF86fZ+7552Rn376F3XK+dvrUadreUpz7OO/au0eTwpQDZDH0HZLL5U6dPm3OvLksSLN2KuAkfuM/S01NbcjQoXQ7K2VlZU9PT9QOrdAhIRvQkEgkCg8NQxxYSSKRsG9wvHHjxnv+3IfBcSLMzc2PnzzRxsGB6RfCgnZuZm5+9MRxDI5/ce7MWQyOs15RYWF4GHU9EKZuPVx3p3Zo64AWwwg6DRuu37hh647tenp6sjqHm9cxy5htYblz5w62Hf+n7Kys2NhY2p6enZ3d0WNHLSwsUFPUEAqFm7ZsGeXjw47LiY2JRdrAevD09lJRUaHVKbkMdMVu8rSSnpaWnJyMOMC/unXzJoIAjGBmbn7wyGEk9CZIS0tr157dtF2cKid69up1+OgRNOy/u3TxIoIgD27eoK4HwuDUfFpaWrv27Bnl48OCCXEsxufzhw0fHnjhfM9evWR4GuXl5YmJiaiOf/r48WNOTg5DTz42JhY1+K9inr+g8+kZNGly+NjR3s7OqClpMzU1PXLsKMs2JImNiUHN1qPL5DZ4MK36Bj5s+WbDol8WHqnwTW/evGHu3mjfwmV+jnr4SuvWrfcfPNCwYUOEgiwFBYVZc2avXL1KIBAgGtR3maZOm7Z+4wYE/+9SUlKymL/tD/xQDyQ+vqqqippjMbtbwOPxpk6ftm7DBiR3oqe2bdueCAiYM28uZRsGfUtmZiYmGn9LRkYGQ888k7FnLv06Taf5GSorK69dv27O3LlfchQDcb169zpy/JiRsTHLris9PR2VWw/ePqPo83Pr7eyMnGm0e3Bk4pEK3ySRSD59+sSyi1JSUkLNsonrwIG79+1l30b59NGvf/8TASetbawRCsoYGBj8eWD/qNGYUvC1d1jxJjeqq6s/fPhAzbHY8Nm8Z6+eAWdO29vbo+nQR+PGjTds2rh7314zczM6nE8Jdh7/NlFxMVPPHNX6DcXFzIjMsBHDDx4+1MTQEFVGlqKi4oyZM9dtYOdME/zw60dXV7e/ywA6nAmXyx3jOwY1QjfoKYG83XuVlZWVlZVRsyygoKAwdfq0pcuXKSgoIBpS1dTI6PDRo55eXljBTwHnPn1Onj7VomVLhOKfsPM4+qjSwJJlZfr6+vsO7J8waSKfz0frkS1NLa3pM2cEBl3o0bMnrbpNqJpvYe6vBtXKgjq1sbUNOH2KVjs/MJ2ZufmRY0c9vb1Y27wV8KCvpzG+vnS4bXbp2tXUzAzVQb9HKn5Z8P17Lws7XY0aNULNMp22tvYfu3eNwp5dFL5lzJg1c8fvO3V1dRENKREKhctXrlizbq3MV+ED0KOPSlEPhD3brnG5XP+xYw8cOmRuYY4GJBMCgcB/3NjgiyFe3t502zMB+9CxMjg6DZHb7RuRYVTWO4FAsGjJ4m07tuM19defgyNGjjx24rillRWbmzd++PXVpEmT3s69ZX4aozF5HA8OYCBWJtTFtzqms7e3P3EqwKFtW4SCYk4dOpwJPOc2eDAmkhPXuUuXM4HnBri4IBTfoaWlhSDIUR+VqgErtqUlada82YmAgAmTJmJHOSqpqKh4enkFhQRPmDiRnh85GxsYYDe6f6WoqMjcdwNLSyvU4L+ytmbezoCdOnc+ez7Q3cMD/ez60dPX37Vn96w5s1n/+LOywsaX9TfG10+2P7G2bdu2aNECFUFDFpYWCAJ8i6aWFivnirZq1YpIObq6usYmJmgnVOLz+b9NmbzvwH7MgpIVNTW1RUsW79qz2wAJRcjdaVetWb11+zbMGfpPZuaYFCsvtCjsgbAwbbeCgoL/2LEnT59q3bo1GpO0CQSCUT4+IaGXZsyaSfN5JU4dOqC+/sm+dWvm7r3o1MEJNfgvt3Uez5GZkVFTU1uwaOGfBw9YWlqiHn/qFXGUj8+584Ft27Vj/cWqq6u3smuFSv+F1wmzrt26yvAERvv6ohboqY2DA/Zihm/2uJwcWXldHTp1JFJO9549Tp89M33mDEzHoepZZn742NExvr6YVCFzbdu1OxN4zn/cWDxBfvH1zW3w4MAL5/v264do/AgLCwuse5MTHQk9qX/ol8jWIBobG+87sH/t+nX4niklmpqafv7+F8NCp06f1qBBA/qf8GAPd9TaP7l7eDD4raZjR8wZ+ZdHSMeOjJ7kZWdndzzg5Oy5czQ0NFCb/x0ue7sTAQFTp09TUVGRh+t1cXVFopFf5OvnJ6tD29ratndsjyqgJ1VV1Z69eiEO8K8GDhrEyuuysLCwtiGwJqlr164KCgpe3t5BIcFDhw3Dc0p6VFRUpkydevJUABPXSrKVsrLyhIkTz5w727VbN0SjHlrZ2R09cXzRksWampqIxo8b4IotaOTCYHfqBqx47A5lb2fncxfOT5k6VSgUomGRYmRkNH/hgtDL4RN/m8Sgm7iDg0PHTp1QfX/XslWrnr16Mvf8FRQUxo4bh3r8KiYTJk1i+lXweLzhI0YEXQzx9PKiWzID+tBp2HDp8mX7Dx40M5eX7VM1NDTG+Pmi6n+RbbNm7R1lMxUU1Udz/uPG4pYL/9TGwYHF65PG/PKiFhsbmy/x0dDUnDt/3plzZ/v268fj8dB4yOrarduZc2d9xoxWYGO2WKYzaNJk89Ytv+/6w8oKG2D+qMaNG69cverAoYP43lMPXt7eGOWTh9s+lUuHFVauXMnugCooKNjZ2w0a7MbhcJKSkqqrq9HI6ofL5bZ3dJwxa9bc+fNsmzVj4syIVnZ24aFhVVVVqE0Oh6OkpLRt+/YG2g0YfRW2zWxfvHj+6eMnVGgdXz+/vv36suNalJWVnTo49e/fv6RE9P7d+9raWtRvHaFQ6D927Nr165o1a/aLReXn5YUEBzPlwufOn29nb4cG8Ov09fUvh4dTfFATE5O58+cj+HSmqanJ5/OjnkYhFPCFqqrqtp07WDyr0dTMLC4u7sOHD/X753w+f92G9Xp6el/9lHr07NHLuXdhYWFqaio6ML+ueYvma9at8xk9GjvY0JyhoaH7EA8jY+N3yclFRUUIyLfo6OhMnjJl+aqVVhgZry+BQKDVQOvB/QcIBYvfebft3EFlgkOuXD2wCwoKTp44EXwhqLy8HK3tp96XXAa6egwZYmhoyPRreRYdPXvmrIqKCjmv07refLfu3VlwLUVFReP9x6anp+On2r1Hjw2bNrJyK8aUlJRDBw7euX27pqZGnqtYSUlpyNChvv5+pIYq3iYl+XiPYsS1+4wePWXaVPzMSZkwbnxcbCyVR1y+csUAF6yEZYAVy5Zfu3oVcYC67uKmrVs6sX39ZV5e3jg//0+f6jPZYs68ecOGD/vOH6SnpZ05febK5ct4+6gfKysrX39/Ri94lU8SiSQ8LOz4seMf6/vxia00tbQ8vTxHenrKydaI0rZ969bAc4GIA/uoqKjs/ON3e2qTSnLl8IN2fn7+hfPngy8EFRYWotl9B4/Ha9uunYurS4+ePZWUlFhzXREREcsWLxGLxXJbs0pKSkuWLWVT9o/8/Pw5s2a/iY+X5x+s68CBi5YsZveC07S0tBPHjl27ek0OVwKpqKgMchvk7ePz1SS1X8SU8XFPb68ZM2fiuUzQo4hHsykMqb6+ftDFEKyIZ4Ta2totmzYFBwUjFHJOKBSuXruWyrxYMpSRkTF9ytSfGiLn8Xhz5s0dMnToj/xxQUHB+cDAkKDggoICNK0f1KJFC19/v85duiAUzFVTU3Pzxs1TAScTExIRDX19fU9vr8Hu7shlStbePXtOHj+BlTpsoqamtm7DeqcOHSg+Lldum1FFRcWVy1fOnTmTmpqK9vcVMzOz/gMG9BvQv1GjRuzsBKenb9qwMTo6Wg4rt5Wd3cJFi9i3YbFEIjl04ODpU6fkcHqOjo7OlGnTBrgMkJPrzc7OPnf2bOjFSyUlJfJwvdra2kOHDxs6bJg0EpbSf3xcX19/9tw5yPgkDaNH+SQlUvS++p9TLIFubt648cfO33NychAK+eTk5LRg0cLGBgbyc8mFhYVrVq2KeBjxI39sZGS0ZPkyO7uf2/JLIpHcuX07JDj4+bPnGMr5FkVFxZ69eg0fOaJ58+aIBms8ffL0zOnTTx4/ls+VoLa2tiO9PJ379EFaAimJePhwy6bNWVlZCAV6IL+Ci2fzs2fPQi9eunvnDla9mZmZ9ezVq0evnubm5nJS9SFBwY8iIuRhLrmKiopThw7uQzwcZZSWjRqfP38ODgq6ce16ZmYm6+uUy+Xa2Nq6uLq4Dhwohwv0SktLr4RfDrpwgcXfOK1trD2GDBng4iK9jHm0HR9XUFBo0bKFq+vAfgP6I2GglNy+dXvxwoUUHEhbWzsk9BJmSzFO3VSSy2Fh8fHxcr63lfwQCoWdOnd2H+Jhb28vnxG4d/fu0cNHEhISvvUH+vr63qNGeQwd8isLYjIyMi6HhV+7erV+m7qwlZGx8QCXAYPc3LS1tRENVvr08ePFkIthoaH5+fnycL0CgaBP377uQzxsbGxQ+9JWVVX115UrYZdCX79+jU4LE6mrq3fp2sXdw6Nlq1ayOgeMj/9PaWnptatXr4Rffv36tVzFhMfj2Taz7dy5S49ePU1MTOTzThofH/8uOfld8rvPnz+LxeKyMjHTd6hXUlJWU1NTVVXV0dExtzC3tLKytbVl0yY5/ykzMzMpMfH9u/epqaklIpG4rKy8rExSI2HuFSnwFFRVVdWEakKh0NTUzMLSwrZZMx0dHdy9Xzx/Hnop9M7t26xJLCEUCvv17z/Izc3K2krax0pLS6NmhPT7FPmKAlVVVVWBtraOubm5mbm5bTNb5OCiwIxp03Jzc6V9lMGD3YeNGI5oM1dBQUF8fHzy27cp71NEomKxuEwsLkXGe6bjcrjKKsoCgaqamqq+fmMzczMLS0sbGxvsg8ThcNLT0iIjIxPeJBTk5xcWFiopK2tra1taWrZu06aNQxuCB4qJibn219Xbt28XyfG2n9ra2t179nBxdcWEcTlRXV195/ada1evPo6MZOWjhMvltmzVql//fn379aMytSB86bS8fvUq5X1KWlpaQUG+WFxWJhZXVVchMvTsgTQxNDQzM7OwsLCytpb5AguMj38tJzv79q3bt27efPXqFYuDo6Gh0d7RsVPnzh07dWRxSnoAkBNisfjWzVs3rl9/Fh0tkTDyQ4iiomLbdu2c+/Tp1bsXZtoCAADIiZqamri4uIf3H9y/d09+Es7r6el179Gje4/u9q1bszK3PPyn4qKiW7duX792LTYmhh0Tfi0tLfv07evct4++vj7qF4BxMD7+TTk5OREPIx5HRj6LjmbHLrdCodC+des2Dm3atm1HwbREAADqFRQU3L1z9/69e8+ioysrK+l/wgKBoGOnjl27devcpQvmmAAAAMiz9LS0J4+fREVFPX/2jH15VlRUVOzt7ds7OXbo0MHUzAzVDV9675GPHj2KePQ4MpJxzZ7P59u3bt2la5euXbvKVc4GAPbB+Ph/k0gkcbGx0VHRsbGxr1+9KisrY8qZ83g8ExOTZs2bN2/RokXLFhYWFvg4DwByory8/OmTJ0+fPH3y+HFGRgatzk1BQcHK2trBwcGhrUMbBwfMFgcAAIC/q6mpiY+Pj4uNff3q1cu4l8xNlquppWVnZ9fKrpW9vb2NrS2fz0flwrdIJJLYmNjnz569ePH81ctXtM0Px+PxzM3NW7dp3bpNm/aOjpjgAsAOGB//6Vv227dvX8bGxcfHJyUlpqWm0WrPLBUVFVMzMysrK0srSwtLS0tLS9ysAQCysrJePH8R8+LFy7i41NRUmSzhVFNTs7S0tG3WrG73UqFQiHoBAACAH5GTnf369eu3b98mJSYlv32bnZ1Nz7d4Lperq6tramZma2trZW1lY2ODGbVQP1VVVa9evoyLi0tKTExISPz44YNs27ymlpatjY21jU2Lli3sW7dGmhwA9sH4+K/etd+9e5f89m1aWlpmRmZmRkZmZiY1E8w1NTV1aGNVBgAABE5JREFUdXX19PSaGhk1NWpqaNjUyNgIG10BAHxfeXl5QkLC28Sk5OTk5OS3aalp0ljIqaio2NjAoGlTQxMTU2sbGxsbayNjYwQfAAAAfl1JSUlqSkpGRmZGRnp6WnpmRkZOTk5BQQGVr/Z8Pl9XV7exQePGjQ0aN25s2NTQ2MTE2NhYIBCggoC44uLipMTEd+/epaWlpaelZ6Sn5+TkSK/Bq6urGxkbGRkZGxsbm5iaWFtb40sPAOthfJy8/Ly8nM+fcz9//vw5Nz8vLzc3VyQSlf5PSUlJaUV5efXfcDgcHo+noKCgqKioqKjI5/NVBAJVgUCgqqoqEKiqqWlqajbQbtBAq4GmllaDBlqNdHX19PTQ8wAAIEIkEmVmZHz69CknOyc7Jzs/L7+osLCwsFBUUlImFpeVlVVXV0skkpqaGi6Xq6SkVHejVlZWVlJS0tDU0NLS0tLS0tTS0tTU1NbWMWhi0NTQUFdPD4EFAAAAylRVVeXk5GRlZeXl5hUVFhYV1XVnCktEInFZWZlYXPeflZWVdR2bur5N3b+textVUFDg8/nKKnWUVVRUBAJVTU0NoVBdXV1dqC5s0KBBw0aNdHR0GjVqpK2tja07QYbKy8uzsrLqRl1ycrJzP+cWFRWKRCUlIlHd8EtlZaVEIqmqqqqqqqrrxvP5/C9DLqqqqkL1OkJ1dY2GDRs20m3UsFGjRg0b6enraWpqIsIA8gbj4wAAAAAAAAAAwEK1tbX4nAMA34fxcQAAAAAAAAAAAACQRzyEAAAAAAAAAAAAAADkEMbHAQAAAAAAAAAAAEAeYXwcAAAAAAAAAAAAAOQRxscBAAAAAAAAAAAAQB5hfBwAAAAAAAAAAAAA5BHGxwEAAAAAAAAAAABAHmF8HAAAAAAAAAAAAADkEcbHAQAAAAAAAAAAAEAeYXwcAAAAAAAAAAAAAOQRxscBAAAAAAAAAAAAQB5hfBwAAAAAAAAAAAAA5BHGxwEAAAAAAAAAAABAHmF8HAAAAAAAAAAAAADkEcbHAQAAAAAAAAAAAEAeYXwcAAAAAAAAAAAAAOQRxscBAAAAAAAAAAAAQB5hfBwAAAAAAAAAAAAA5BHGxwEAAAAAAAAAAABAHmF8HAAAAAAAAAAAAADkEcbHAQAAAAAAAAAAAEAeYXwcAAAAAAAAAAAAAOQRxscBAAAAAAAAAAAAQB5hfBwAAAAAAAAAAAAA5BHGxwEAAAAAAAAAAABAHmF8HAAAAAAAAAAAAADkEcbHAQAAAAAAAAAAAEAeYXwcAAAAAAAAAAAAAOQRxscBAAAAAAAAAAAAQB5hfBwAAAAAAAAAAAAA5BHGxwEAAAAAAAAAAABAHmF8HAAAAAAAAAAAAADkEcbHAQAAAAAAAAAAAEAeYXwcAAAAAAAAAAAAAOQRxscBAAAAAAAAAAAAQB5hfBwAAAAAAAAAAAAA5BHGxwEAAAAAAAAAAABAHv0fr+hlXOtHm2kAAAAASUVORK5CYII="); } cadvisor-0.25.0/pages/containers.go000066400000000000000000000141131306035727200172100ustar00rootroot00000000000000// 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" "net/http" "net/url" "path" "strconv" "strings" "time" info "github.com/google/cadvisor/info/v1" "github.com/google/cadvisor/manager" "github.com/golang/glog" ) const ContainersPage = "/containers/" // from http://golang.org/doc/effective_go.html#constants type ByteSize float64 const ( _ = iota // KB - kilobyte KB ByteSize = 1 << (10 * iota) // MB - megabyte MB // GB - gigabyte GB // TB - terabyte TB // PB - petabyte PB // EB - exabyte EB // ZB - zettabyte ZB // YB - yottabyte YB ) func (b ByteSize) Size() string { for _, i := range [...]ByteSize{YB, ZB, EB, PB, TB, GB, MB, KB} { if b >= i { return fmt.Sprintf("%.2f", b/i) } } return fmt.Sprintf("%.2f", b) } func (b ByteSize) Unit() string { switch { case b >= YB: return "YB" case b >= ZB: return "ZB" case b >= EB: return "EB" case b >= PB: return "PB" case b >= TB: return "TB" case b >= GB: return "GB" case b >= MB: return "MB" case b >= KB: return "KB" } return "B" } var funcMap = template.FuncMap{ "printMask": printMask, "printCores": printCores, "printShares": printShares, "printSize": printSize, "printUnit": printUnit, } func printMask(mask string, numCores int) interface{} { masks := make([]string, numCores) activeCores := getActiveCores(mask) for i := 0; i < numCores; i++ { coreClass := "inactive-cpu" if activeCores[i] { coreClass = "active-cpu" } masks[i] = fmt.Sprintf("%d", coreClass, i) } return template.HTML(strings.Join(masks, " ")) } func getActiveCores(mask string) map[int]bool { activeCores := make(map[int]bool) for _, corebits := range strings.Split(mask, ",") { cores := strings.Split(corebits, "-") if len(cores) == 1 { index, err := strconv.Atoi(cores[0]) if err != nil { // Ignore malformed strings. continue } activeCores[index] = true } else if len(cores) == 2 { start, err := strconv.Atoi(cores[0]) if err != nil { continue } end, err := strconv.Atoi(cores[1]) if err != nil { continue } for i := start; i <= end; i++ { activeCores[i] = true } } } return activeCores } func printCores(millicores *uint64) string { cores := float64(*millicores) / 1000 return strconv.FormatFloat(cores, 'f', 3, 64) } func printShares(shares *uint64) string { return fmt.Sprintf("%d", *shares) } // Size after which we consider memory to be "unlimited". This is not // MaxInt64 due to rounding by the kernel. const maxMemorySize = uint64(1 << 62) func printSize(bytes uint64) string { if bytes >= maxMemorySize { return "unlimited" } return ByteSize(bytes).Size() } func printUnit(bytes uint64) string { if bytes >= maxMemorySize { return "" } return ByteSize(bytes).Unit() } func serveContainersPage(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. reqParams := info.ContainerInfoRequest{ NumStats: 60, } cont, err := m.GetContainerInfo(containerName, &reqParams) if err != nil { return fmt.Errorf("failed to get container %q with error: %v", containerName, err) } displayName := getContainerDisplayName(cont.ContainerReference) // Get the MachineInfo machineInfo, err := m.GetMachineInfo() if err != nil { return err } rootDir := getRootDir(containerName) // Make a list of the parent containers and their links pathParts := strings.Split(string(cont.Name), "/") parentContainers := make([]link, 0, len(pathParts)) parentContainers = append(parentContainers, link{ Text: "root", Link: path.Join(rootDir, ContainersPage), }) for i := 1; i < len(pathParts); i++ { // Skip empty parts. if pathParts[i] == "" { continue } parentContainers = append(parentContainers, link{ Text: pathParts[i], Link: path.Join(rootDir, ContainersPage, path.Join(pathParts[1:i+1]...)), }) } // Build the links for the subcontainers. subcontainerLinks := make([]link, 0, len(cont.Subcontainers)) for _, sub := range cont.Subcontainers { if !m.Exists(sub.Name) { continue } subcontainerLinks = append(subcontainerLinks, link{ Text: getContainerDisplayName(sub), Link: path.Join(rootDir, ContainersPage, sub.Name), }) } data := &pageData{ DisplayName: displayName, ContainerName: escapeContainerName(cont.Name), ParentContainers: parentContainers, Subcontainers: subcontainerLinks, Spec: cont.Spec, Stats: cont.Stats, MachineInfo: machineInfo, IsRoot: cont.Name == "/", ResourcesAvailable: cont.Spec.HasCpu || cont.Spec.HasMemory || cont.Spec.HasNetwork || cont.Spec.HasFilesystem, CpuAvailable: cont.Spec.HasCpu, MemoryAvailable: cont.Spec.HasMemory, NetworkAvailable: cont.Spec.HasNetwork, FsAvailable: cont.Spec.HasFilesystem, CustomMetricsAvailable: cont.Spec.HasCustomMetrics, SubcontainersAvailable: len(subcontainerLinks) > 0, Root: rootDir, } err = pageTemplate.Execute(w, data) if err != nil { glog.Errorf("Failed to apply template: %s", err) } glog.V(5).Infof("Request took %s", time.Since(start)) return nil } // Build a relative path to the root of the container page. func getRootDir(containerName string) string { // The root is at: container depth levels := (strings.Count(containerName, "/")) return strings.Repeat("../", levels) } cadvisor-0.25.0/pages/docker.go000066400000000000000000000111231306035727200163100ustar00rootroot00000000000000// 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 import ( "fmt" "net/http" "net/url" "path" "strconv" "time" "github.com/google/cadvisor/container/docker" info "github.com/google/cadvisor/info/v1" "github.com/google/cadvisor/manager" "github.com/golang/glog" ) const DockerPage = "/docker/" func toStatusKV(status info.DockerStatus) ([]keyVal, []keyVal) { ds := []keyVal{ {Key: "Driver", Value: status.Driver}, } for k, v := range status.DriverStatus { ds = append(ds, keyVal{Key: k, Value: v}) } return []keyVal{ {Key: "Docker Version", Value: status.Version}, {Key: "Kernel Version", Value: status.KernelVersion}, {Key: "OS Version", Value: status.OS}, {Key: "Host Name", Value: status.Hostname}, {Key: "Docker Root Directory", Value: status.RootDir}, {Key: "Execution Driver", Value: status.ExecDriver}, {Key: "Number of Images", Value: strconv.Itoa(status.NumImages)}, {Key: "Number of Containers", Value: strconv.Itoa(status.NumContainers)}, }, ds } func serveDockerPage(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(DockerPage)-1:] rootDir := getRootDir(containerName) var data *pageData if containerName == "/" { // Get the containers. reqParams := info.ContainerInfoRequest{ NumStats: 0, } conts, err := m.AllDockerContainers(&reqParams) if err != nil { return fmt.Errorf("failed to get container %q with error: %v", containerName, err) } subcontainers := make([]link, 0, len(conts)) for _, cont := range conts { subcontainers = append(subcontainers, link{ Text: getContainerDisplayName(cont.ContainerReference), Link: path.Join(rootDir, DockerPage, docker.ContainerNameToDockerId(cont.ContainerReference.Name)), }) } // Get Docker status status, err := m.DockerInfo() if err != nil { return err } dockerStatus, driverStatus := toStatusKV(status) // Get Docker Images images, err := m.DockerImages() if err != nil { return err } dockerContainersText := "Docker Containers" data = &pageData{ DisplayName: dockerContainersText, ParentContainers: []link{ { Text: dockerContainersText, Link: path.Join(rootDir, DockerPage), }}, Subcontainers: subcontainers, Root: rootDir, DockerStatus: dockerStatus, DockerDriverStatus: driverStatus, DockerImages: images, } } else { // Get the container. reqParams := info.ContainerInfoRequest{ NumStats: 60, } cont, err := m.DockerContainer(containerName[1:], &reqParams) if err != nil { return fmt.Errorf("failed to get container %q with error: %v", containerName, err) } displayName := getContainerDisplayName(cont.ContainerReference) // Make a list of the parent containers and their links var parentContainers []link parentContainers = append(parentContainers, link{ Text: "Docker Containers", Link: path.Join(rootDir, DockerPage), }) parentContainers = append(parentContainers, link{ Text: displayName, Link: path.Join(rootDir, DockerPage, docker.ContainerNameToDockerId(cont.Name)), }) // Get the MachineInfo machineInfo, err := m.GetMachineInfo() if err != nil { return err } data = &pageData{ DisplayName: displayName, ContainerName: escapeContainerName(cont.Name), ParentContainers: parentContainers, Spec: cont.Spec, Stats: cont.Stats, MachineInfo: machineInfo, ResourcesAvailable: cont.Spec.HasCpu || cont.Spec.HasMemory || cont.Spec.HasNetwork, CpuAvailable: cont.Spec.HasCpu, MemoryAvailable: cont.Spec.HasMemory, NetworkAvailable: cont.Spec.HasNetwork, FsAvailable: cont.Spec.HasFilesystem, CustomMetricsAvailable: cont.Spec.HasCustomMetrics, Root: rootDir, } } err := pageTemplate.Execute(w, data) if err != nil { glog.Errorf("Failed to apply template: %s", err) } glog.V(5).Infof("Request took %s", time.Since(start)) return nil } cadvisor-0.25.0/pages/pages.go000066400000000000000000000121071306035727200161430ustar00rootroot00000000000000// 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 import ( "fmt" "html/template" "net/http" "net/url" "strings" httpmux "github.com/google/cadvisor/http/mux" info "github.com/google/cadvisor/info/v1" "github.com/google/cadvisor/manager" auth "github.com/abbot/go-http-auth" "github.com/golang/glog" ) var pageTemplate *template.Template type link struct { // Text to show in the link. Text string // Web address to link to. Link string } type keyVal struct { Key string Value string } type pageData struct { DisplayName string ContainerName string ParentContainers []link Subcontainers []link Spec info.ContainerSpec Stats []*info.ContainerStats MachineInfo *info.MachineInfo IsRoot bool ResourcesAvailable bool CpuAvailable bool MemoryAvailable bool NetworkAvailable bool FsAvailable bool CustomMetricsAvailable bool SubcontainersAvailable bool Root string DockerStatus []keyVal DockerDriverStatus []keyVal DockerImages []info.DockerImage } func init() { containersHtmlTemplate, _ := Asset("pages/assets/html/containers.html") pageTemplate = template.New("containersTemplate").Funcs(funcMap) _, err := pageTemplate.Parse(string(containersHtmlTemplate)) if err != nil { glog.Fatalf("Failed to parse template: %s", err) } } func containerHandlerNoAuth(containerManager manager.Manager) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { err := serveContainersPage(containerManager, w, r.URL) if err != nil { fmt.Fprintf(w, "%s", err) } } } func containerHandler(containerManager manager.Manager) auth.AuthenticatedHandlerFunc { return func(w http.ResponseWriter, r *auth.AuthenticatedRequest) { err := serveContainersPage(containerManager, w, r.URL) if err != nil { fmt.Fprintf(w, "%s", err) } } } func dockerHandlerNoAuth(containerManager manager.Manager) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { err := serveDockerPage(containerManager, w, r.URL) if err != nil { fmt.Fprintf(w, "%s", err) } } } func dockerHandler(containerManager manager.Manager) auth.AuthenticatedHandlerFunc { return func(w http.ResponseWriter, r *auth.AuthenticatedRequest) { err := serveDockerPage(containerManager, w, r.URL) if err != nil { fmt.Fprintf(w, "%s", err) } } } // Register http handlers func RegisterHandlersDigest(mux httpmux.Mux, containerManager manager.Manager, authenticator *auth.DigestAuth) error { // Register the handler for the containers page. if authenticator != nil { mux.HandleFunc(ContainersPage, authenticator.Wrap(containerHandler(containerManager))) mux.HandleFunc(DockerPage, authenticator.Wrap(dockerHandler(containerManager))) } else { mux.HandleFunc(ContainersPage, containerHandlerNoAuth(containerManager)) mux.HandleFunc(DockerPage, dockerHandlerNoAuth(containerManager)) } return nil } func RegisterHandlersBasic(mux httpmux.Mux, containerManager manager.Manager, authenticator *auth.BasicAuth) error { // Register the handler for the containers and docker age. if authenticator != nil { mux.HandleFunc(ContainersPage, authenticator.Wrap(containerHandler(containerManager))) mux.HandleFunc(DockerPage, authenticator.Wrap(dockerHandler(containerManager))) } else { mux.HandleFunc(ContainersPage, containerHandlerNoAuth(containerManager)) mux.HandleFunc(DockerPage, dockerHandlerNoAuth(containerManager)) } return nil } func getContainerDisplayName(cont info.ContainerReference) string { // Pick a user-added alias as display name. displayName := "" for _, alias := range cont.Aliases { // ignore container id as alias. if strings.Contains(cont.Name, alias) { continue } // pick shortest display name if multiple aliases are available. if displayName == "" || len(displayName) >= len(alias) { displayName = alias } } if displayName == "" { displayName = cont.Name } else if len(displayName) > 50 { // truncate display name to fit in one line. displayName = displayName[:50] + "..." } // Add the full container name to the display name. if displayName != cont.Name { displayName = fmt.Sprintf("%s (%s)", displayName, cont.Name) } return displayName } // Escape the non-path characters on a container name. func escapeContainerName(containerName string) string { parts := strings.Split(containerName, "/") for i := range parts { parts[i] = url.QueryEscape(parts[i]) } return strings.Join(parts, "/") } cadvisor-0.25.0/pages/static/000077500000000000000000000000001306035727200160035ustar00rootroot00000000000000cadvisor-0.25.0/pages/static/static.go000066400000000000000000000043761306035727200176330ustar00rootroot00000000000000// 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" "mime" "net/http" "net/url" "path" ) const StaticResource = "/static/" var bootstrapJs, _ = Asset("pages/assets/js/bootstrap-3.1.1.min.js") var containersJs, _ = Asset("pages/assets/js/containers.js") var gchartsJs, _ = Asset("pages/assets/js/gcharts.js") var googleJsapiJs, _ = Asset("pages/assets/js/google-jsapi.js") var jqueryJs, _ = Asset("pages/assets/js/jquery-1.10.2.min.js") var bootstrapCss, _ = Asset("pages/assets/styles/bootstrap-3.1.1.min.css") var bootstrapThemeCss, _ = Asset("pages/assets/styles/bootstrap-theme-3.1.1.min.css") var containersCss, _ = Asset("pages/assets/styles/containers.css") var staticFiles = map[string][]byte{ "bootstrap-3.1.1.min.css": bootstrapCss, "bootstrap-3.1.1.min.js": bootstrapJs, "bootstrap-theme-3.1.1.min.css": bootstrapThemeCss, "containers.css": containersCss, "containers.js": containersJs, "gcharts.js": gchartsJs, "google-jsapi.js": googleJsapiJs, "jquery-1.10.2.min.js": jqueryJs, } 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) } // Set Content-Type if we were able to detect it. contentType := mime.TypeByExtension(path.Ext(resource)) if contentType != "" { w.Header().Set("Content-Type", contentType) } _, err := w.Write(content) return err } cadvisor-0.25.0/storage/000077500000000000000000000000001306035727200150615ustar00rootroot00000000000000cadvisor-0.25.0/storage/bigquery/000077500000000000000000000000001306035727200167105ustar00rootroot00000000000000cadvisor-0.25.0/storage/bigquery/README.md000066400000000000000000000016541306035727200201750ustar00rootroot00000000000000BigQuery Storage Driver ======= [EXPERIMENTAL] Support for BigQuery backend as cAdvisor storage driver. The current implementation takes bunch of BigQuery specific flags for authentication. These will be merged into a single backend config. To run the current version, following flags need to be specified: ``` # Storage driver to use. -storage_driver=bigquery # Information about server-to-server Oauth token. # These can be obtained by creating a Service Account client id under `Google Developer API` # service client id -bq_id="XYZ.apps.googleusercontent.com" # service email address -bq_account="ABC@developer.gserviceaccount.com" # path to pem key (converted from p12 file) -bq_credentials_file="/path/to/key.pem" # project id to use for storing datasets. -bq_project_id="awesome_project" ``` See [Service account Authentication](https://developers.google.com/accounts/docs/OAuth2) for Oauth related details. cadvisor-0.25.0/storage/bigquery/bigquery.go000066400000000000000000000173431306035727200210760ustar00rootroot00000000000000// 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 bigquery import ( "os" info "github.com/google/cadvisor/info/v1" "github.com/google/cadvisor/storage" "github.com/google/cadvisor/storage/bigquery/client" bigquery "google.golang.org/api/bigquery/v2" ) func init() { storage.RegisterStorageDriver("bigquery", new) } type bigqueryStorage struct { client *client.Client machineName string } const ( // Bigquery schema types typeTimestamp string = "TIMESTAMP" typeString string = "STRING" typeInteger string = "INTEGER" colTimestamp string = "timestamp" colMachineName string = "machine" colContainerName string = "container_name" colCpuCumulativeUsage string = "cpu_cumulative_usage" // Cumulative Cpu usage in system and user mode colCpuCumulativeUsageSystem string = "cpu_cumulative_usage_system" colCpuCumulativeUsageUser string = "cpu_cumulative_usage_user" // Memory usage colMemoryUsage string = "memory_usage" // Working set size colMemoryWorkingSet string = "memory_working_set" // Container page fault colMemoryContainerPgfault string = "memory_container_pgfault" // Constainer major page fault colMemoryContainerPgmajfault string = "memory_container_pgmajfault" // Hierarchical page fault colMemoryHierarchicalPgfault string = "memory_hierarchical_pgfault" // Hierarchical major page fault colMemoryHierarchicalPgmajfault string = "memory_hierarchical_pgmajfault" // Cumulative count of bytes received. colRxBytes string = "rx_bytes" // Cumulative count of receive errors encountered. colRxErrors string = "rx_errors" // Cumulative count of bytes transmitted. colTxBytes string = "tx_bytes" // Cumulative count of transmit errors encountered. colTxErrors string = "tx_errors" // Filesystem device. colFsDevice = "fs_device" // Filesystem limit. colFsLimit = "fs_limit" // Filesystem available space. colFsUsage = "fs_usage" ) func new() (storage.StorageDriver, error) { hostname, err := os.Hostname() if err != nil { return nil, err } return newStorage( hostname, *storage.ArgDbTable, *storage.ArgDbName, ) } // TODO(jnagal): Infer schema through reflection. (See bigquery/client/example) func (self *bigqueryStorage) GetSchema() *bigquery.TableSchema { fields := make([]*bigquery.TableFieldSchema, 19) i := 0 fields[i] = &bigquery.TableFieldSchema{ Type: typeTimestamp, Name: colTimestamp, Mode: "REQUIRED", } i++ fields[i] = &bigquery.TableFieldSchema{ Type: typeString, Name: colMachineName, Mode: "REQUIRED", } i++ fields[i] = &bigquery.TableFieldSchema{ Type: typeString, Name: colContainerName, Mode: "REQUIRED", } i++ fields[i] = &bigquery.TableFieldSchema{ Type: typeInteger, Name: colCpuCumulativeUsage, } i++ fields[i] = &bigquery.TableFieldSchema{ Type: typeInteger, Name: colCpuCumulativeUsageSystem, } i++ fields[i] = &bigquery.TableFieldSchema{ Type: typeInteger, Name: colCpuCumulativeUsageUser, } i++ fields[i] = &bigquery.TableFieldSchema{ Type: typeInteger, Name: colMemoryUsage, } i++ fields[i] = &bigquery.TableFieldSchema{ Type: typeInteger, Name: colMemoryWorkingSet, } i++ fields[i] = &bigquery.TableFieldSchema{ Type: typeInteger, Name: colMemoryContainerPgfault, } i++ fields[i] = &bigquery.TableFieldSchema{ Type: typeInteger, Name: colMemoryContainerPgmajfault, } i++ fields[i] = &bigquery.TableFieldSchema{ Type: typeInteger, Name: colMemoryHierarchicalPgfault, } i++ fields[i] = &bigquery.TableFieldSchema{ Type: typeInteger, Name: colMemoryHierarchicalPgmajfault, } i++ fields[i] = &bigquery.TableFieldSchema{ Type: typeInteger, Name: colRxBytes, } i++ fields[i] = &bigquery.TableFieldSchema{ Type: typeInteger, Name: colRxErrors, } i++ fields[i] = &bigquery.TableFieldSchema{ Type: typeInteger, Name: colTxBytes, } i++ fields[i] = &bigquery.TableFieldSchema{ Type: typeInteger, Name: colTxErrors, } i++ fields[i] = &bigquery.TableFieldSchema{ Type: typeString, Name: colFsDevice, } i++ fields[i] = &bigquery.TableFieldSchema{ Type: typeInteger, Name: colFsLimit, } i++ fields[i] = &bigquery.TableFieldSchema{ Type: typeInteger, Name: colFsUsage, } return &bigquery.TableSchema{ Fields: fields, } } func (self *bigqueryStorage) containerStatsToRows( ref info.ContainerReference, stats *info.ContainerStats, ) (row map[string]interface{}) { row = make(map[string]interface{}) // Timestamp row[colTimestamp] = stats.Timestamp // Machine name row[colMachineName] = self.machineName // Container name name := ref.Name if len(ref.Aliases) > 0 { name = ref.Aliases[0] } row[colContainerName] = name // Cumulative Cpu Usage row[colCpuCumulativeUsage] = stats.Cpu.Usage.Total // Cumulative Cpu Usage in system mode row[colCpuCumulativeUsageSystem] = stats.Cpu.Usage.System // Cumulative Cpu Usage in user mode row[colCpuCumulativeUsageUser] = stats.Cpu.Usage.User // Memory Usage row[colMemoryUsage] = stats.Memory.Usage // Working set size row[colMemoryWorkingSet] = stats.Memory.WorkingSet // container page fault row[colMemoryContainerPgfault] = stats.Memory.ContainerData.Pgfault // container major page fault row[colMemoryContainerPgmajfault] = stats.Memory.ContainerData.Pgmajfault // hierarchical page fault row[colMemoryHierarchicalPgfault] = stats.Memory.HierarchicalData.Pgfault // hierarchical major page fault row[colMemoryHierarchicalPgmajfault] = stats.Memory.HierarchicalData.Pgmajfault // Network stats. row[colRxBytes] = stats.Network.RxBytes row[colRxErrors] = stats.Network.RxErrors row[colTxBytes] = stats.Network.TxBytes row[colTxErrors] = stats.Network.TxErrors // TODO(jnagal): Handle per-cpu stats. return } func (self *bigqueryStorage) containerFilesystemStatsToRows( ref info.ContainerReference, stats *info.ContainerStats, ) (rows []map[string]interface{}) { for _, fsStat := range stats.Filesystem { row := make(map[string]interface{}, 0) row[colFsDevice] = fsStat.Device row[colFsLimit] = fsStat.Limit row[colFsUsage] = fsStat.Usage rows = append(rows, row) } return rows } func (self *bigqueryStorage) AddStats(ref info.ContainerReference, stats *info.ContainerStats) error { if stats == nil { return nil } rows := make([]map[string]interface{}, 0) rows = append(rows, self.containerStatsToRows(ref, stats)) rows = append(rows, self.containerFilesystemStatsToRows(ref, stats)...) for _, row := range rows { err := self.client.InsertRow(row) if err != nil { return err } } return nil } func (self *bigqueryStorage) Close() error { self.client.Close() self.client = nil return nil } // Create a new bigquery storage driver. // machineName: A unique identifier to identify the host that current cAdvisor // instance is running on. // tableName: BigQuery table used for storing stats. func newStorage(machineName, datasetId, tableName string) (storage.StorageDriver, error) { bqClient, err := client.NewClient() if err != nil { return nil, err } err = bqClient.CreateDataset(datasetId) if err != nil { return nil, err } ret := &bigqueryStorage{ client: bqClient, machineName: machineName, } schema := ret.GetSchema() err = bqClient.CreateTable(tableName, schema) if err != nil { return nil, err } return ret, nil } cadvisor-0.25.0/storage/bigquery/client/000077500000000000000000000000001306035727200201665ustar00rootroot00000000000000cadvisor-0.25.0/storage/bigquery/client/client.go000066400000000000000000000145441306035727200220030ustar00rootroot00000000000000// 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 client import ( "flag" "fmt" "io/ioutil" "strings" "golang.org/x/oauth2" "golang.org/x/oauth2/jwt" bigquery "google.golang.org/api/bigquery/v2" ) var ( // TODO(jnagal): Condense all flags to an identity file and a pem key file. clientId = flag.String("bq_id", "", "Client ID") clientSecret = flag.String("bq_secret", "notasecret", "Client Secret") projectId = flag.String("bq_project_id", "", "Bigquery project ID") serviceAccount = flag.String("bq_account", "", "Service account email") pemFile = flag.String("bq_credentials_file", "", "Credential Key file (pem)") ) const ( errAlreadyExists string = "Error 409: Already Exists" ) type Client struct { service *bigquery.Service token *oauth2.Token datasetId string tableId string } // Helper method to create an authenticated connection. func connect() (*oauth2.Token, *bigquery.Service, error) { if *clientId == "" { return nil, nil, fmt.Errorf("no client id specified") } if *serviceAccount == "" { return nil, nil, fmt.Errorf("no service account specified") } if *projectId == "" { return nil, nil, fmt.Errorf("no project id specified") } authScope := bigquery.BigqueryScope if *pemFile == "" { return nil, nil, fmt.Errorf("no credentials specified") } pemBytes, err := ioutil.ReadFile(*pemFile) if err != nil { return nil, nil, fmt.Errorf("could not access credential file %v - %v", pemFile, err) } jwtConfig := &jwt.Config{ Email: *serviceAccount, Scopes: []string{authScope}, PrivateKey: pemBytes, TokenURL: "https://accounts.google.com/o/oauth2/token", } token, err := jwtConfig.TokenSource(oauth2.NoContext).Token() if err != nil { return nil, nil, err } if !token.Valid() { return nil, nil, fmt.Errorf("invalid token for BigQuery oauth") } config := &oauth2.Config{ ClientID: *clientId, ClientSecret: *clientSecret, Scopes: []string{authScope}, Endpoint: oauth2.Endpoint{ AuthURL: "https://accounts.google.com/o/oauth2/auth", TokenURL: "https://accounts.google.com/o/oauth2/token", }, } client := config.Client(oauth2.NoContext, token) service, err := bigquery.New(client) if err != nil { fmt.Printf("Failed to create new service: %v\n", err) return nil, nil, err } return token, service, nil } // Creates a new client instance with an authenticated connection to bigquery. func NewClient() (*Client, error) { token, service, err := connect() if err != nil { return nil, err } c := &Client{ token: token, service: service, } return c, nil } func (c *Client) Close() error { c.service = nil return nil } // Helper method to return the bigquery service connection. // Expired connection is refreshed. func (c *Client) getService() (*bigquery.Service, error) { if c.token == nil || c.service == nil { return nil, fmt.Errorf("service not initialized") } // Refresh expired token. if !c.token.Valid() { token, service, err := connect() if err != nil { return nil, err } c.token = token c.service = service return service, nil } return c.service, nil } func (c *Client) PrintDatasets() error { datasetList, err := c.service.Datasets.List(*projectId).Do() if err != nil { fmt.Printf("Failed to get list of datasets\n") return err } else { fmt.Printf("Successfully retrieved datasets. Retrieved: %d\n", len(datasetList.Datasets)) } for _, d := range datasetList.Datasets { fmt.Printf("%s %s\n", d.Id, d.FriendlyName) } return nil } func (c *Client) CreateDataset(datasetId string) error { if c.service == nil { return fmt.Errorf("no service created") } _, err := c.service.Datasets.Insert(*projectId, &bigquery.Dataset{ DatasetReference: &bigquery.DatasetReference{ DatasetId: datasetId, ProjectId: *projectId, }, }).Do() // TODO(jnagal): Do a Get() to verify dataset already exists. if err != nil && !strings.Contains(err.Error(), errAlreadyExists) { return err } c.datasetId = datasetId return nil } // Create a table with provided table ID and schema. // Schema is currently not updated if the table already exists. func (c *Client) CreateTable(tableId string, schema *bigquery.TableSchema) error { if c.service == nil || c.datasetId == "" { return fmt.Errorf("no dataset created") } _, err := c.service.Tables.Get(*projectId, c.datasetId, tableId).Do() if err != nil { // Create a new table. _, err := c.service.Tables.Insert(*projectId, c.datasetId, &bigquery.Table{ Schema: schema, TableReference: &bigquery.TableReference{ DatasetId: c.datasetId, ProjectId: *projectId, TableId: tableId, }, }).Do() if err != nil { return err } } // TODO(jnagal): Update schema if it has changed. We can only extend existing schema. c.tableId = tableId return nil } // Add a row to the connected table. func (c *Client) InsertRow(rowData map[string]interface{}) error { service, _ := c.getService() if service == nil || c.datasetId == "" || c.tableId == "" { return fmt.Errorf("table not setup to add rows") } jsonRows := make(map[string]bigquery.JsonValue) for key, value := range rowData { jsonRows[key] = bigquery.JsonValue(value) } rows := []*bigquery.TableDataInsertAllRequestRows{ { Json: jsonRows, }, } // TODO(jnagal): Batch insert requests. insertRequest := &bigquery.TableDataInsertAllRequest{Rows: rows} result, err := service.Tabledata.InsertAll(*projectId, c.datasetId, c.tableId, insertRequest).Do() if err != nil { return fmt.Errorf("error inserting row: %v", err) } if len(result.InsertErrors) > 0 { errstr := fmt.Sprintf("Insertion for %d rows failed\n", len(result.InsertErrors)) for _, errors := range result.InsertErrors { for _, errorproto := range errors.Errors { errstr += fmt.Sprintf("Error inserting row %d: %+v\n", errors.Index, errorproto) } } return fmt.Errorf(errstr) } return nil } cadvisor-0.25.0/storage/bigquery/client/example/000077500000000000000000000000001306035727200216215ustar00rootroot00000000000000cadvisor-0.25.0/storage/bigquery/client/example/example.go000066400000000000000000000042601306035727200236050ustar00rootroot00000000000000// 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" "time" "github.com/SeanDolphin/bqschema" "github.com/google/cadvisor/storage/bigquery/client" ) type container struct { Name string `json:"name"` CpuUsage uint64 `json:"cpuusage,omitempty"` MemoryUsage uint64 `json:"memoryusage,omitempty"` NetworkUsage uint64 `json:"networkusage,omitempty"` Timestamp time.Time `json:"timestamp"` } func main() { flag.Parse() c, err := client.NewClient() if err != nil { fmt.Printf("Failed to connect to bigquery\n") panic(err) } c.PrintDatasets() // Create a new dataset. err = c.CreateDataset("sampledataset") if err != nil { fmt.Printf("Failed to create dataset %v\n", err) panic(err) } // Create a new table containerData := container{ Name: "test_container", CpuUsage: 123456, MemoryUsage: 1024, NetworkUsage: 9046, Timestamp: time.Now(), } schema, err := bqschema.ToSchema(containerData) if err != nil { fmt.Printf("Failed to create schema") panic(err) } err = c.CreateTable("sampletable", schema) if err != nil { fmt.Printf("Failed to create table") panic(err) } // Add Data m := make(map[string]interface{}) t := time.Now() for i := 0; i < 10; i++ { m["Name"] = containerData.Name m["CpuUsage"] = containerData.CpuUsage + uint64(i*100) m["MemoryUsage"] = containerData.MemoryUsage - uint64(i*10) m["NetworkUsage"] = containerData.NetworkUsage + uint64(i*10) m["Timestamp"] = t.Add(time.Duration(i) * time.Second) err = c.InsertRow(m) if err != nil { fmt.Printf("Failed to insert row") panic(err) } } } cadvisor-0.25.0/storage/common_flags.go000066400000000000000000000025641306035727200200630ustar00rootroot00000000000000// Copyright 2015 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 ( "flag" "time" ) var ArgDbUsername = flag.String("storage_driver_user", "root", "database username") var ArgDbPassword = flag.String("storage_driver_password", "root", "database password") var ArgDbHost = flag.String("storage_driver_host", "localhost:8086", "database host:port") var ArgDbName = flag.String("storage_driver_db", "cadvisor", "database name") var ArgDbTable = flag.String("storage_driver_table", "stats", "table name") var ArgDbIsSecure = flag.Bool("storage_driver_secure", false, "use secure connection with database") var ArgDbBufferDuration = flag.Duration("storage_driver_buffer_duration", 60*time.Second, "Writes in the storage driver will be buffered for this duration, and committed to the non memory backends as a single transaction") cadvisor-0.25.0/storage/elasticsearch/000077500000000000000000000000001306035727200176735ustar00rootroot00000000000000cadvisor-0.25.0/storage/elasticsearch/elasticsearch.go000066400000000000000000000107251306035727200230410ustar00rootroot00000000000000// Copyright 2015 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 elasticsearch import ( "flag" "fmt" "os" "sync" "time" info "github.com/google/cadvisor/info/v1" storage "github.com/google/cadvisor/storage" "gopkg.in/olivere/elastic.v2" ) func init() { storage.RegisterStorageDriver("elasticsearch", new) } type elasticStorage struct { client *elastic.Client machineName string indexName string typeName string lock sync.Mutex } type detailSpec struct { Timestamp int64 `json:"timestamp"` MachineName string `json:"machine_name,omitempty"` ContainerName string `json:"container_Name,omitempty"` ContainerStats *info.ContainerStats `json:"container_stats,omitempty"` } var ( argElasticHost = flag.String("storage_driver_es_host", "http://localhost:9200", "ElasticSearch host:port") argIndexName = flag.String("storage_driver_es_index", "cadvisor", "ElasticSearch index name") argTypeName = flag.String("storage_driver_es_type", "stats", "ElasticSearch type name") argEnableSniffer = flag.Bool("storage_driver_es_enable_sniffer", false, "ElasticSearch uses a sniffing process to find all nodes of your cluster by default, automatically") ) func new() (storage.StorageDriver, error) { hostname, err := os.Hostname() if err != nil { return nil, err } return newStorage( hostname, *argIndexName, *argTypeName, *argElasticHost, *argEnableSniffer, ) } func (self *elasticStorage) containerStatsAndDefaultValues( ref info.ContainerReference, stats *info.ContainerStats) *detailSpec { timestamp := stats.Timestamp.UnixNano() / 1E3 var containerName string if len(ref.Aliases) > 0 { containerName = ref.Aliases[0] } else { containerName = ref.Name } detail := &detailSpec{ Timestamp: timestamp, MachineName: self.machineName, ContainerName: containerName, ContainerStats: stats, } return detail } func (self *elasticStorage) AddStats(ref info.ContainerReference, stats *info.ContainerStats) error { if stats == nil { return nil } func() { // AddStats will be invoked simultaneously from multiple threads and only one of them will perform a write. self.lock.Lock() defer self.lock.Unlock() // Add some default params based on ContainerStats detail := self.containerStatsAndDefaultValues(ref, stats) // Index a cadvisor (using JSON serialization) _, err := self.client.Index(). Index(self.indexName). Type(self.typeName). BodyJson(detail). Do() if err != nil { // Handle error fmt.Printf("failed to write stats to ElasticSearch - %s", err) return } }() return nil } func (self *elasticStorage) Close() error { self.client = nil return nil } // machineName: A unique identifier to identify the host that current cAdvisor // instance is running on. // ElasticHost: The host which runs ElasticSearch. func newStorage( machineName, indexName, typeName, elasticHost string, enableSniffer bool, ) (storage.StorageDriver, error) { // Obtain a client and connect to the default Elasticsearch installation // on 127.0.0.1:9200. Of course you can configure your client to connect // to other hosts and configure it in various other ways. client, err := elastic.NewClient( elastic.SetHealthcheck(true), elastic.SetSniff(enableSniffer), elastic.SetHealthcheckInterval(30*time.Second), elastic.SetURL(elasticHost), ) if err != nil { // Handle error return nil, fmt.Errorf("failed to create the elasticsearch client - %s", err) } // Ping the Elasticsearch server to get e.g. the version number info, code, err := client.Ping().URL(elasticHost).Do() if err != nil { // Handle error return nil, fmt.Errorf("failed to ping the elasticsearch - %s", err) } fmt.Printf("Elasticsearch returned with code %d and version %s", code, info.Version.Number) ret := &elasticStorage{ client: client, machineName: machineName, indexName: indexName, typeName: typeName, } return ret, nil } cadvisor-0.25.0/storage/influxdb/000077500000000000000000000000001306035727200166745ustar00rootroot00000000000000cadvisor-0.25.0/storage/influxdb/influxdb.go000066400000000000000000000231251306035727200210410ustar00rootroot00000000000000// 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 influxdb import ( "fmt" "net/url" "os" "sync" "time" info "github.com/google/cadvisor/info/v1" "github.com/google/cadvisor/storage" "github.com/google/cadvisor/version" influxdb "github.com/influxdb/influxdb/client" ) func init() { storage.RegisterStorageDriver("influxdb", new) } type influxdbStorage struct { client *influxdb.Client machineName string database string retentionPolicy string bufferDuration time.Duration lastWrite time.Time points []*influxdb.Point lock sync.Mutex readyToFlush func() bool } // Series names const ( // Cumulative CPU usage serCpuUsageTotal string = "cpu_usage_total" serCpuUsageSystem string = "cpu_usage_system" serCpuUsageUser string = "cpu_usage_user" serCpuUsagePerCpu string = "cpu_usage_per_cpu" // Smoothed average of number of runnable threads x 1000. serLoadAverage string = "load_average" // Memory Usage serMemoryUsage string = "memory_usage" // Working set size serMemoryWorkingSet string = "memory_working_set" // Cumulative count of bytes received. serRxBytes string = "rx_bytes" // Cumulative count of receive errors encountered. serRxErrors string = "rx_errors" // Cumulative count of bytes transmitted. serTxBytes string = "tx_bytes" // Cumulative count of transmit errors encountered. serTxErrors string = "tx_errors" // Filesystem device. serFsDevice string = "fs_device" // Filesystem limit. serFsLimit string = "fs_limit" // Filesystem usage. serFsUsage string = "fs_usage" ) func new() (storage.StorageDriver, error) { hostname, err := os.Hostname() if err != nil { return nil, err } return newStorage( hostname, *storage.ArgDbTable, *storage.ArgDbName, *storage.ArgDbUsername, *storage.ArgDbPassword, *storage.ArgDbHost, *storage.ArgDbIsSecure, *storage.ArgDbBufferDuration, ) } // Field names const ( fieldValue string = "value" fieldType string = "type" fieldDevice string = "device" ) // Tag names const ( tagMachineName string = "machine" tagContainerName string = "container_name" ) func (self *influxdbStorage) containerFilesystemStatsToPoints( ref info.ContainerReference, stats *info.ContainerStats) (points []*influxdb.Point) { if len(stats.Filesystem) == 0 { return points } for _, fsStat := range stats.Filesystem { tagsFsUsage := map[string]string{ fieldDevice: fsStat.Device, fieldType: "usage", } fieldsFsUsage := map[string]interface{}{ fieldValue: int64(fsStat.Usage), } pointFsUsage := &influxdb.Point{ Measurement: serFsUsage, Tags: tagsFsUsage, Fields: fieldsFsUsage, } tagsFsLimit := map[string]string{ fieldDevice: fsStat.Device, fieldType: "limit", } fieldsFsLimit := map[string]interface{}{ fieldValue: int64(fsStat.Limit), } pointFsLimit := &influxdb.Point{ Measurement: serFsLimit, Tags: tagsFsLimit, Fields: fieldsFsLimit, } points = append(points, pointFsUsage, pointFsLimit) } self.tagPoints(ref, stats, points) return points } // Set tags and timestamp for all points of the batch. // Points should inherit the tags that are set for BatchPoints, but that does not seem to work. func (self *influxdbStorage) tagPoints(ref info.ContainerReference, stats *info.ContainerStats, points []*influxdb.Point) { // Use container alias if possible var containerName string if len(ref.Aliases) > 0 { containerName = ref.Aliases[0] } else { containerName = ref.Name } commonTags := map[string]string{ tagMachineName: self.machineName, tagContainerName: containerName, } for i := 0; i < len(points); i++ { // merge with existing tags if any addTagsToPoint(points[i], commonTags) addTagsToPoint(points[i], ref.Labels) points[i].Time = stats.Timestamp } } func (self *influxdbStorage) containerStatsToPoints( ref info.ContainerReference, stats *info.ContainerStats, ) (points []*influxdb.Point) { // CPU usage: Total usage in nanoseconds points = append(points, makePoint(serCpuUsageTotal, stats.Cpu.Usage.Total)) // CPU usage: Time spend in system space (in nanoseconds) points = append(points, makePoint(serCpuUsageSystem, stats.Cpu.Usage.System)) // CPU usage: Time spent in user space (in nanoseconds) points = append(points, makePoint(serCpuUsageUser, stats.Cpu.Usage.User)) // CPU usage per CPU for i := 0; i < len(stats.Cpu.Usage.PerCpu); i++ { point := makePoint(serCpuUsagePerCpu, stats.Cpu.Usage.PerCpu[i]) tags := map[string]string{"instance": fmt.Sprintf("%v", i)} addTagsToPoint(point, tags) points = append(points, point) } // Load Average points = append(points, makePoint(serLoadAverage, stats.Cpu.LoadAverage)) // Memory Usage points = append(points, makePoint(serMemoryUsage, stats.Memory.Usage)) // Working Set Size points = append(points, makePoint(serMemoryWorkingSet, stats.Memory.WorkingSet)) // Network Stats points = append(points, makePoint(serRxBytes, stats.Network.RxBytes)) points = append(points, makePoint(serRxErrors, stats.Network.RxErrors)) points = append(points, makePoint(serTxBytes, stats.Network.TxBytes)) points = append(points, makePoint(serTxErrors, stats.Network.TxErrors)) self.tagPoints(ref, stats, points) return points } func (self *influxdbStorage) OverrideReadyToFlush(readyToFlush func() bool) { self.readyToFlush = readyToFlush } func (self *influxdbStorage) defaultReadyToFlush() bool { return time.Since(self.lastWrite) >= self.bufferDuration } func (self *influxdbStorage) AddStats(ref info.ContainerReference, stats *info.ContainerStats) error { if stats == nil { return nil } var pointsToFlush []*influxdb.Point func() { // AddStats will be invoked simultaneously from multiple threads and only one of them will perform a write. self.lock.Lock() defer self.lock.Unlock() self.points = append(self.points, self.containerStatsToPoints(ref, stats)...) self.points = append(self.points, self.containerFilesystemStatsToPoints(ref, stats)...) if self.readyToFlush() { pointsToFlush = self.points self.points = make([]*influxdb.Point, 0) self.lastWrite = time.Now() } }() if len(pointsToFlush) > 0 { points := make([]influxdb.Point, len(pointsToFlush)) for i, p := range pointsToFlush { points[i] = *p } batchTags := map[string]string{tagMachineName: self.machineName} bp := influxdb.BatchPoints{ Points: points, Database: self.database, Tags: batchTags, Time: stats.Timestamp, } response, err := self.client.Write(bp) if err != nil || checkResponseForErrors(response) != nil { return fmt.Errorf("failed to write stats to influxDb - %s", err) } } return nil } func (self *influxdbStorage) Close() error { self.client = nil return nil } // machineName: A unique identifier to identify the host that current cAdvisor // instance is running on. // influxdbHost: The host which runs influxdb (host:port) func newStorage( machineName, tablename, database, username, password, influxdbHost string, isSecure bool, bufferDuration time.Duration, ) (*influxdbStorage, error) { url := &url.URL{ Scheme: "http", Host: influxdbHost, } if isSecure { url.Scheme = "https" } config := &influxdb.Config{ URL: *url, Username: username, Password: password, UserAgent: fmt.Sprintf("%v/%v", "cAdvisor", version.Info["version"]), } client, err := influxdb.NewClient(*config) if err != nil { return nil, err } ret := &influxdbStorage{ client: client, machineName: machineName, database: database, bufferDuration: bufferDuration, lastWrite: time.Now(), points: make([]*influxdb.Point, 0), } ret.readyToFlush = ret.defaultReadyToFlush return ret, nil } // Creates a measurement point with a single value field func makePoint(name string, value interface{}) *influxdb.Point { fields := map[string]interface{}{ fieldValue: toSignedIfUnsigned(value), } return &influxdb.Point{ Measurement: name, Fields: fields, } } // Adds additional tags to the existing tags of a point func addTagsToPoint(point *influxdb.Point, tags map[string]string) { if point.Tags == nil { point.Tags = tags } else { for k, v := range tags { point.Tags[k] = v } } } // Checks response for possible errors func checkResponseForErrors(response *influxdb.Response) error { const msg = "failed to write stats to influxDb - %s" if response != nil && response.Err != nil { return fmt.Errorf(msg, response.Err) } if response != nil && response.Results != nil { for _, result := range response.Results { if result.Err != nil { return fmt.Errorf(msg, result.Err) } if result.Series != nil { for _, row := range result.Series { if row.Err != nil { return fmt.Errorf(msg, row.Err) } } } } } return nil } // Some stats have type unsigned integer, but the InfluxDB client accepts only signed integers. func toSignedIfUnsigned(value interface{}) interface{} { switch v := value.(type) { case uint64: return int64(v) case uint32: return int32(v) case uint16: return int16(v) case uint8: return int8(v) case uint: return int(v) } return value } cadvisor-0.25.0/storage/influxdb/influxdb_test.go000066400000000000000000000176571306035727200221150ustar00rootroot00000000000000// Copyright 2014 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // +build influxdb_test // To run unit test: go test -tags influxdb_test package influxdb import ( "fmt" "math/rand" "net/url" "reflect" "testing" "time" info "github.com/google/cadvisor/info/v1" "github.com/google/cadvisor/storage" "github.com/google/cadvisor/storage/test" influxdb "github.com/influxdb/influxdb/client" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" ) // The duration in seconds for which stats will be buffered in the influxdb driver. const kCacheDuration = 1 type influxDbTestStorageDriver struct { count int buffer int base storage.StorageDriver } func (self *influxDbTestStorageDriver) readyToFlush() bool { return self.count >= self.buffer } func (self *influxDbTestStorageDriver) AddStats(ref info.ContainerReference, stats *info.ContainerStats) error { self.count++ return self.base.AddStats(ref, stats) } func (self *influxDbTestStorageDriver) Close() error { return self.base.Close() } func (self *influxDbTestStorageDriver) StatsEq(a, b *info.ContainerStats) bool { if !test.TimeEq(a.Timestamp, b.Timestamp, 10*time.Millisecond) { return false } // Check only the stats populated in influxdb. if !reflect.DeepEqual(a.Cpu.Usage, b.Cpu.Usage) { return false } if a.Memory.Usage != b.Memory.Usage { return false } if a.Memory.WorkingSet != b.Memory.WorkingSet { return false } if !reflect.DeepEqual(a.Network, b.Network) { return false } if !reflect.DeepEqual(a.Filesystem, b.Filesystem) { return false } return true } func runStorageTest(f func(test.TestStorageDriver, *testing.T), t *testing.T, bufferCount int) { machineName := "machineA" table := "cadvisor_table" database := "cadvisor_test" username := "root" password := "root" hostname := "localhost:8086" // percentilesDuration := 10 * time.Minute config := influxdb.Config{ URL: url.URL{Scheme: "http", Host: hostname}, Username: username, Password: password, } client, err := influxdb.NewClient(config) if err != nil { t.Fatal(err) } // Re-create the database first. if err := prepareDatabase(client, database); err != nil { t.Fatal(err) } // Delete all data by the end of the call. // defer client.Query(influxdb.Query{Command: fmt.Sprintf("drop database \"%v\"", database)}) driver, err := newStorage(machineName, table, database, username, password, hostname, false, time.Duration(bufferCount)) if err != nil { t.Fatal(err) } defer driver.Close() testDriver := &influxDbTestStorageDriver{buffer: bufferCount} driver.OverrideReadyToFlush(testDriver.readyToFlush) testDriver.base = driver // Generate another container's data on same machine. test.StorageDriverFillRandomStatsFunc("containerOnSameMachine", 100, testDriver, t) // Generate another container's data on another machine. driverForAnotherMachine, err := newStorage("machineB", table, database, username, password, hostname, false, time.Duration(bufferCount)) if err != nil { t.Fatal(err) } defer driverForAnotherMachine.Close() testDriverOtherMachine := &influxDbTestStorageDriver{buffer: bufferCount} driverForAnotherMachine.OverrideReadyToFlush(testDriverOtherMachine.readyToFlush) testDriverOtherMachine.base = driverForAnotherMachine test.StorageDriverFillRandomStatsFunc("containerOnAnotherMachine", 100, testDriverOtherMachine, t) f(testDriver, t) } func prepareDatabase(client *influxdb.Client, database string) error { dropDbQuery := influxdb.Query{ Command: fmt.Sprintf("drop database \"%v\"", database), } createDbQuery := influxdb.Query{ Command: fmt.Sprintf("create database \"%v\"", database), } // A default retention policy must always be present. // Depending on the InfluxDB configuration it may be created automatically with the database or not. // TODO create ret. policy only if not present createPolicyQuery := influxdb.Query{ Command: fmt.Sprintf("create retention policy \"default\" on \"%v\" duration 1h replication 1 default", database), } _, err := client.Query(dropDbQuery) if err != nil { return err } _, err = client.Query(createDbQuery) if err != nil { return err } _, err = client.Query(createPolicyQuery) return err } func TestContainerFileSystemStatsToPoints(t *testing.T) { assert := assert.New(t) machineName := "testMachine" table := "cadvisor_table" database := "cadvisor_test" username := "root" password := "root" influxdbHost := "localhost:8086" storage, err := newStorage(machineName, table, database, username, password, influxdbHost, false, 2*time.Minute) assert.Nil(err) ref := info.ContainerReference{ Name: "containerName", } stats := &info.ContainerStats{} points := storage.containerFilesystemStatsToPoints(ref, stats) // stats.Filesystem is always nil, not sure why assert.Nil(points) } func TestContainerStatsToPoints(t *testing.T) { // Given storage, err := createTestStorage() require.Nil(t, err) require.NotNil(t, storage) ref, stats := createTestStats() require.Nil(t, err) require.NotNil(t, stats) // When points := storage.containerStatsToPoints(*ref, stats) // Then assert.NotEmpty(t, points) assert.Len(t, points, 10+len(stats.Cpu.Usage.PerCpu)) assertContainsPointWithValue(t, points, serCpuUsageTotal, stats.Cpu.Usage.Total) assertContainsPointWithValue(t, points, serCpuUsageSystem, stats.Cpu.Usage.System) assertContainsPointWithValue(t, points, serCpuUsageUser, stats.Cpu.Usage.User) assertContainsPointWithValue(t, points, serMemoryUsage, stats.Memory.Usage) assertContainsPointWithValue(t, points, serLoadAverage, stats.Cpu.LoadAverage) assertContainsPointWithValue(t, points, serMemoryWorkingSet, stats.Memory.WorkingSet) assertContainsPointWithValue(t, points, serRxBytes, stats.Network.RxBytes) assertContainsPointWithValue(t, points, serRxErrors, stats.Network.RxErrors) assertContainsPointWithValue(t, points, serTxBytes, stats.Network.TxBytes) assertContainsPointWithValue(t, points, serTxBytes, stats.Network.TxErrors) for _, cpu_usage := range stats.Cpu.Usage.PerCpu { assertContainsPointWithValue(t, points, serCpuUsagePerCpu, cpu_usage) } } func assertContainsPointWithValue(t *testing.T, points []*influxdb.Point, name string, value interface{}) bool { found := false for _, point := range points { if point.Measurement == name && point.Fields[fieldValue] == toSignedIfUnsigned(value) { found = true break } } return assert.True(t, found, "no point found with name='%v' and value=%v", name, value) } func createTestStorage() (*influxdbStorage, error) { machineName := "testMachine" table := "cadvisor_table" database := "cadvisor_test" username := "root" password := "root" influxdbHost := "localhost:8086" storage, err := newStorage(machineName, table, database, username, password, influxdbHost, false, 2*time.Minute) return storage, err } func createTestStats() (*info.ContainerReference, *info.ContainerStats) { ref := &info.ContainerReference{ Name: "testContainername", Aliases: []string{"testContainerAlias1", "testContainerAlias2"}, } cpuUsage := info.CpuUsage{ Total: uint64(rand.Intn(10000)), PerCpu: []uint64{uint64(rand.Intn(1000)), uint64(rand.Intn(1000)), uint64(rand.Intn(1000))}, User: uint64(rand.Intn(10000)), System: uint64(rand.Intn(10000)), } stats := &info.ContainerStats{ Timestamp: time.Now(), Cpu: info.CpuStats{ Usage: cpuUsage, LoadAverage: int32(rand.Intn(1000)), }, } return ref, stats } cadvisor-0.25.0/storage/kafka/000077500000000000000000000000001306035727200161365ustar00rootroot00000000000000cadvisor-0.25.0/storage/kafka/kafka.go000066400000000000000000000104171306035727200175450ustar00rootroot00000000000000// Copyright 2016 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package kafka import ( "crypto/tls" "crypto/x509" "encoding/json" "flag" "io/ioutil" "os" "strings" "time" info "github.com/google/cadvisor/info/v1" "github.com/google/cadvisor/storage" "github.com/google/cadvisor/utils/container" kafka "github.com/Shopify/sarama" "github.com/golang/glog" ) func init() { storage.RegisterStorageDriver("kafka", new) } var ( brokers = flag.String("storage_driver_kafka_broker_list", "localhost:9092", "kafka broker(s) csv") topic = flag.String("storage_driver_kafka_topic", "stats", "kafka topic") certFile = flag.String("storage_driver_kafka_ssl_cert", "", "optional certificate file for TLS client authentication") keyFile = flag.String("storage_driver_kafka_ssl_key", "", "optional key file for TLS client authentication") caFile = flag.String("storage_driver_kafka_ssl_ca", "", "optional certificate authority file for TLS client authentication") verifySSL = flag.Bool("storage_driver_kafka_ssl_verify", true, "verify ssl certificate chain") ) type kafkaStorage struct { producer kafka.AsyncProducer topic string machineName string } type detailSpec struct { Timestamp time.Time `json:"timestamp"` MachineName string `json:"machine_name,omitempty"` ContainerName string `json:"container_Name,omitempty"` ContainerID string `json:"container_Id,omitempty"` ContainerLabels map[string]string `json:"container_labels,omitempty"` ContainerStats *info.ContainerStats `json:"container_stats,omitempty"` } func (driver *kafkaStorage) infoToDetailSpec(ref info.ContainerReference, stats *info.ContainerStats) *detailSpec { timestamp := time.Now() containerID := ref.Id containerLabels := ref.Labels containerName := container.GetPreferredName(ref) detail := &detailSpec{ Timestamp: timestamp, MachineName: driver.machineName, ContainerName: containerName, ContainerID: containerID, ContainerLabels: containerLabels, ContainerStats: stats, } return detail } func (driver *kafkaStorage) AddStats(ref info.ContainerReference, stats *info.ContainerStats) error { detail := driver.infoToDetailSpec(ref, stats) b, err := json.Marshal(detail) driver.producer.Input() <- &kafka.ProducerMessage{ Topic: driver.topic, Value: kafka.StringEncoder(b), } return err } func (self *kafkaStorage) Close() error { return self.producer.Close() } func new() (storage.StorageDriver, error) { machineName, err := os.Hostname() if err != nil { return nil, err } return newStorage(machineName) } func generateTLSConfig() (*tls.Config, error) { if *certFile != "" && *keyFile != "" && *caFile != "" { cert, err := tls.LoadX509KeyPair(*certFile, *keyFile) if err != nil { return nil, err } caCert, err := ioutil.ReadFile(*caFile) if err != nil { return nil, err } caCertPool := x509.NewCertPool() caCertPool.AppendCertsFromPEM(caCert) return &tls.Config{ Certificates: []tls.Certificate{cert}, RootCAs: caCertPool, InsecureSkipVerify: *verifySSL, }, nil } return nil, nil } func newStorage(machineName string) (storage.StorageDriver, error) { config := kafka.NewConfig() tlsConfig, err := generateTLSConfig() if err != nil { return nil, err } if tlsConfig != nil { config.Net.TLS.Enable = true config.Net.TLS.Config = tlsConfig } config.Producer.RequiredAcks = kafka.WaitForAll brokerList := strings.Split(*brokers, ",") glog.V(4).Infof("Kafka brokers:%q", brokers) producer, err := kafka.NewAsyncProducer(brokerList, config) if err != nil { return nil, err } ret := &kafkaStorage{ producer: producer, topic: *topic, machineName: machineName, } return ret, nil } cadvisor-0.25.0/storage/redis/000077500000000000000000000000001306035727200161675ustar00rootroot00000000000000cadvisor-0.25.0/storage/redis/redis.go000066400000000000000000000074041306035727200176310ustar00rootroot00000000000000// Copyright 2015 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 redis import ( "encoding/json" "os" "sync" "time" info "github.com/google/cadvisor/info/v1" storage "github.com/google/cadvisor/storage" redis "github.com/garyburd/redigo/redis" ) func init() { storage.RegisterStorageDriver("redis", new) } type redisStorage struct { conn redis.Conn machineName string redisKey string bufferDuration time.Duration lastWrite time.Time lock sync.Mutex readyToFlush func() bool } type detailSpec struct { Timestamp int64 `json:"timestamp"` MachineName string `json:"machine_name,omitempty"` ContainerName string `json:"container_Name,omitempty"` ContainerStats *info.ContainerStats `json:"container_stats,omitempty"` } func new() (storage.StorageDriver, error) { hostname, err := os.Hostname() if err != nil { return nil, err } return newStorage( hostname, *storage.ArgDbName, *storage.ArgDbHost, *storage.ArgDbBufferDuration, ) } func (self *redisStorage) defaultReadyToFlush() bool { return time.Since(self.lastWrite) >= self.bufferDuration } // We must add some default params (for example: MachineName,ContainerName...)because containerStats do not include them func (self *redisStorage) containerStatsAndDefaultValues(ref info.ContainerReference, stats *info.ContainerStats) *detailSpec { timestamp := stats.Timestamp.UnixNano() / 1E3 var containerName string if len(ref.Aliases) > 0 { containerName = ref.Aliases[0] } else { containerName = ref.Name } detail := &detailSpec{ Timestamp: timestamp, MachineName: self.machineName, ContainerName: containerName, ContainerStats: stats, } return detail } // Push the data into redis func (self *redisStorage) AddStats(ref info.ContainerReference, stats *info.ContainerStats) error { if stats == nil { return nil } var seriesToFlush []byte func() { // AddStats will be invoked simultaneously from multiple threads and only one of them will perform a write. self.lock.Lock() defer self.lock.Unlock() // Add some default params based on containerStats detail := self.containerStatsAndDefaultValues(ref, stats) // To json b, _ := json.Marshal(detail) if self.readyToFlush() { seriesToFlush = b self.lastWrite = time.Now() } }() if len(seriesToFlush) > 0 { // We use redis's "LPUSH" to push the data to the redis self.conn.Send("LPUSH", self.redisKey, seriesToFlush) } return nil } func (self *redisStorage) Close() error { return self.conn.Close() } // Create a new redis storage driver. // machineName: A unique identifier to identify the host that runs the current cAdvisor // instance is running on. // redisHost: The host which runs redis. // redisKey: The key for the Data that stored in the redis func newStorage( machineName, redisKey, redisHost string, bufferDuration time.Duration, ) (storage.StorageDriver, error) { conn, err := redis.Dial("tcp", redisHost) if err != nil { return nil, err } ret := &redisStorage{ conn: conn, machineName: machineName, redisKey: redisKey, bufferDuration: bufferDuration, lastWrite: time.Now(), } ret.readyToFlush = ret.defaultReadyToFlush return ret, nil } cadvisor-0.25.0/storage/statsd/000077500000000000000000000000001306035727200163635ustar00rootroot00000000000000cadvisor-0.25.0/storage/statsd/client/000077500000000000000000000000001306035727200176415ustar00rootroot00000000000000cadvisor-0.25.0/storage/statsd/client/client.go000066400000000000000000000031441306035727200214500ustar00rootroot00000000000000// Copyright 2015 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 client import ( "fmt" "net" "github.com/golang/glog" ) type Client struct { HostPort string Namespace string conn net.Conn } func (self *Client) Open() error { conn, err := net.Dial("udp", self.HostPort) if err != nil { glog.Errorf("failed to open udp connection to %q: %v", self.HostPort, err) return err } self.conn = conn return nil } func (self *Client) Close() error { self.conn.Close() self.conn = nil return nil } // Simple send to statsd daemon without sampling. func (self *Client) Send(namespace, containerName, key string, value uint64) error { // only send counter value formatted := fmt.Sprintf("%s.%s.%s:%d|g", namespace, containerName, key, value) _, err := fmt.Fprintf(self.conn, formatted) if err != nil { glog.V(3).Infof("failed to send data %q: %v", formatted, err) return err } return nil } func New(hostPort string) (*Client, error) { Client := Client{HostPort: hostPort} if err := Client.Open(); err != nil { return nil, err } return &Client, nil } cadvisor-0.25.0/storage/statsd/statsd.go000066400000000000000000000076031306035727200202220ustar00rootroot00000000000000// Copyright 2015 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 statsd import ( info "github.com/google/cadvisor/info/v1" "github.com/google/cadvisor/storage" client "github.com/google/cadvisor/storage/statsd/client" ) func init() { storage.RegisterStorageDriver("statsd", new) } type statsdStorage struct { client *client.Client Namespace string } const ( colCpuCumulativeUsage string = "cpu_cumulative_usage" // CPU system colCpuUsageSystem string = "cpu_usage_system" // CPU user colCpuUsageUser string = "cpu_usage_user" // CPU average load colCpuLoadAverage string = "cpu_load_average" // Memory Usage colMemoryUsage string = "memory_usage" // Working set size colMemoryWorkingSet string = "memory_working_set" // Cumulative count of bytes received. colRxBytes string = "rx_bytes" // Cumulative count of receive errors encountered. colRxErrors string = "rx_errors" // Cumulative count of bytes transmitted. colTxBytes string = "tx_bytes" // Cumulative count of transmit errors encountered. colTxErrors string = "tx_errors" // Filesystem summary colFsSummary = "fs_summary" // Filesystem limit. colFsLimit = "fs_limit" // Filesystem usage. colFsUsage = "fs_usage" ) func new() (storage.StorageDriver, error) { return newStorage(*storage.ArgDbName, *storage.ArgDbHost) } func (self *statsdStorage) containerStatsToValues( stats *info.ContainerStats, ) (series map[string]uint64) { series = make(map[string]uint64) // Cumulative Cpu Usage series[colCpuCumulativeUsage] = stats.Cpu.Usage.Total // Cpu usage series[colCpuUsageSystem] = stats.Cpu.Usage.System series[colCpuUsageUser] = stats.Cpu.Usage.User series[colCpuLoadAverage] = uint64(stats.Cpu.LoadAverage) // Memory Usage series[colMemoryUsage] = stats.Memory.Usage // Working set size series[colMemoryWorkingSet] = stats.Memory.WorkingSet // Network stats. series[colRxBytes] = stats.Network.RxBytes series[colRxErrors] = stats.Network.RxErrors series[colTxBytes] = stats.Network.TxBytes series[colTxErrors] = stats.Network.TxErrors return series } func (self *statsdStorage) containerFsStatsToValues( series *map[string]uint64, stats *info.ContainerStats, ) { for _, fsStat := range stats.Filesystem { // Summary stats. (*series)[colFsSummary+"."+colFsLimit] += fsStat.Limit (*series)[colFsSummary+"."+colFsUsage] += fsStat.Usage // Per device stats. (*series)[fsStat.Device+"."+colFsLimit] = fsStat.Limit (*series)[fsStat.Device+"."+colFsUsage] = fsStat.Usage } } // Push the data into redis func (self *statsdStorage) AddStats(ref info.ContainerReference, stats *info.ContainerStats) error { if stats == nil { return nil } var containerName string if len(ref.Aliases) > 0 { containerName = ref.Aliases[0] } else { containerName = ref.Name } series := self.containerStatsToValues(stats) self.containerFsStatsToValues(&series, stats) for key, value := range series { err := self.client.Send(self.Namespace, containerName, key, value) if err != nil { return err } } return nil } func (self *statsdStorage) Close() error { self.client.Close() self.client = nil return nil } func newStorage(namespace, hostPort string) (*statsdStorage, error) { statsdClient, err := client.New(hostPort) if err != nil { return nil, err } statsdStorage := &statsdStorage{ client: statsdClient, Namespace: namespace, } return statsdStorage, nil } cadvisor-0.25.0/storage/stdout/000077500000000000000000000000001306035727200164035ustar00rootroot00000000000000cadvisor-0.25.0/storage/stdout/stdout.go000066400000000000000000000064401306035727200202600ustar00rootroot00000000000000// Copyright 2015 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 stdout import ( "bytes" "fmt" info "github.com/google/cadvisor/info/v1" "github.com/google/cadvisor/storage" ) func init() { storage.RegisterStorageDriver("stdout", new) } type stdoutStorage struct { Namespace string } const ( colCpuCumulativeUsage = "cpu_cumulative_usage" // Memory Usage colMemoryUsage = "memory_usage" // Working set size colMemoryWorkingSet = "memory_working_set" // Cumulative count of bytes received. colRxBytes = "rx_bytes" // Cumulative count of receive errors encountered. colRxErrors = "rx_errors" // Cumulative count of bytes transmitted. colTxBytes = "tx_bytes" // Cumulative count of transmit errors encountered. colTxErrors = "tx_errors" // Filesystem summary colFsSummary = "fs_summary" // Filesystem limit. colFsLimit = "fs_limit" // Filesystem usage. colFsUsage = "fs_usage" ) func new() (storage.StorageDriver, error) { return newStorage(*storage.ArgDbHost) } func (driver *stdoutStorage) containerStatsToValues(stats *info.ContainerStats) (series map[string]uint64) { series = make(map[string]uint64) // Cumulative Cpu Usage series[colCpuCumulativeUsage] = stats.Cpu.Usage.Total // Memory Usage series[colMemoryUsage] = stats.Memory.Usage // Working set size series[colMemoryWorkingSet] = stats.Memory.WorkingSet // Network stats. series[colRxBytes] = stats.Network.RxBytes series[colRxErrors] = stats.Network.RxErrors series[colTxBytes] = stats.Network.TxBytes series[colTxErrors] = stats.Network.TxErrors return series } func (driver *stdoutStorage) containerFsStatsToValues(series *map[string]uint64, stats *info.ContainerStats) { for _, fsStat := range stats.Filesystem { // Summary stats. (*series)[colFsSummary+"."+colFsLimit] += fsStat.Limit (*series)[colFsSummary+"."+colFsUsage] += fsStat.Usage // Per device stats. (*series)[fsStat.Device+"."+colFsLimit] = fsStat.Limit (*series)[fsStat.Device+"."+colFsUsage] = fsStat.Usage } } func (driver *stdoutStorage) AddStats(ref info.ContainerReference, stats *info.ContainerStats) error { if stats == nil { return nil } containerName := ref.Name if len(ref.Aliases) > 0 { containerName = ref.Aliases[0] } var buffer bytes.Buffer buffer.WriteString(fmt.Sprintf("cName=%s host=%s", containerName, driver.Namespace)) series := driver.containerStatsToValues(stats) driver.containerFsStatsToValues(&series, stats) for key, value := range series { buffer.WriteString(fmt.Sprintf(" %s=%v", key, value)) } _, err := fmt.Println(buffer.String()) return err } func (driver *stdoutStorage) Close() error { return nil } func newStorage(namespace string) (*stdoutStorage, error) { stdoutStorage := &stdoutStorage{ Namespace: namespace, } return stdoutStorage, nil } cadvisor-0.25.0/storage/storage.go000066400000000000000000000031421306035727200170540ustar00rootroot00000000000000// 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 ( "fmt" "sort" info "github.com/google/cadvisor/info/v1" ) type StorageDriver interface { AddStats(ref info.ContainerReference, stats *info.ContainerStats) 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 } type StorageDriverFunc func() (StorageDriver, error) var registeredPlugins = map[string](StorageDriverFunc){} func RegisterStorageDriver(name string, f StorageDriverFunc) { registeredPlugins[name] = f } func New(name string) (StorageDriver, error) { if name == "" { return nil, nil } f, ok := registeredPlugins[name] if !ok { return nil, fmt.Errorf("unknown backend storage driver: %s", name) } return f() } func ListDrivers() []string { drivers := make([]string, 0, len(registeredPlugins)) for name := range registeredPlugins { drivers = append(drivers, name) } sort.Strings(drivers) return drivers } cadvisor-0.25.0/storage/test/000077500000000000000000000000001306035727200160405ustar00rootroot00000000000000cadvisor-0.25.0/storage/test/mock.go000066400000000000000000000020751306035727200173240ustar00rootroot00000000000000// 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 ( info "github.com/google/cadvisor/info/v1" "github.com/stretchr/testify/mock" ) type MockStorageDriver struct { mock.Mock MockCloseMethod bool } func (self *MockStorageDriver) AddStats(ref info.ContainerReference, stats *info.ContainerStats) error { args := self.Called(ref, stats) return args.Error(0) } func (self *MockStorageDriver) Close() error { if self.MockCloseMethod { args := self.Called() return args.Error(0) } return nil } cadvisor-0.25.0/storage/test/storagetests.go000066400000000000000000000066301306035727200211230ustar00rootroot00000000000000// 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" "reflect" "testing" "time" info "github.com/google/cadvisor/info/v1" "github.com/google/cadvisor/storage" ) type TestStorageDriver interface { StatsEq(a *info.ContainerStats, b *info.ContainerStats) bool storage.StorageDriver } 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.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.Cpu.Usage.PerCpu = []uint64{cpuTotalUsage} stats.Memory.Usage = mem[i] stats.Network.RxBytes = uint64(rand.Intn(10000)) stats.Network.RxErrors = uint64(rand.Intn(1000)) stats.Network.TxBytes = uint64(rand.Intn(100000)) stats.Network.TxErrors = uint64(rand.Intn(1000)) stats.Filesystem = make([]info.FsStats, 1) stats.Filesystem[0].Device = "/dev/sda1" stats.Filesystem[0].Limit = 1024000000 stats.Filesystem[0].Usage = 1024000 ret[i] = stats } return ret } func TimeEq(t1, t2 time.Time, tolerance time.Duration) bool { // t1 should not be later than t2 if t1.After(t2) { t1, t2 = t2, t1 } diff := t2.Sub(t1) if diff <= tolerance { return true } return false } const ( // 10ms, i.e. 0.01s timePrecision time.Duration = 10 * time.Millisecond ) // This function is useful because we do not require precise time // representation. func DefaultStatsEq(a, b *info.ContainerStats) bool { if !TimeEq(a.Timestamp, b.Timestamp, timePrecision) { return false } if !reflect.DeepEqual(a.Cpu, b.Cpu) { return false } if !reflect.DeepEqual(a.Memory, b.Memory) { return false } if !reflect.DeepEqual(a.Network, b.Network) { return false } if !reflect.DeepEqual(a.Filesystem, b.Filesystem) { return false } return true } // This function will generate random stats and write // them into the storage. The function will not close the driver func StorageDriverFillRandomStatsFunc( containerName string, N int, driver TestStorageDriver, t *testing.T, ) { 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: containerName, } trace := buildTrace(cpuTrace, memTrace, samplePeriod) for _, stats := range trace { err := driver.AddStats(ref, stats) if err != nil { t.Fatalf("unable to add stats: %v", err) } } } cadvisor-0.25.0/storagedriver.go000066400000000000000000000036651306035727200166360ustar00rootroot00000000000000// 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" "strings" "time" "github.com/google/cadvisor/cache/memory" "github.com/google/cadvisor/storage" _ "github.com/google/cadvisor/storage/bigquery" _ "github.com/google/cadvisor/storage/elasticsearch" _ "github.com/google/cadvisor/storage/influxdb" _ "github.com/google/cadvisor/storage/kafka" _ "github.com/google/cadvisor/storage/redis" _ "github.com/google/cadvisor/storage/statsd" _ "github.com/google/cadvisor/storage/stdout" "github.com/golang/glog" ) var ( storageDriver = flag.String("storage_driver", "", fmt.Sprintf("Storage `driver` to use. Data is always cached shortly in memory, this controls where data is pushed besides the local cache. Empty means none. Options are: , %s", strings.Join(storage.ListDrivers(), ", "))) storageDuration = flag.Duration("storage_duration", 2*time.Minute, "How long to keep data stored (Default: 2min).") ) // NewMemoryStorage creates a memory storage with an optional backend storage option. func NewMemoryStorage() (*memory.InMemoryCache, error) { backendStorage, err := storage.New(*storageDriver) if err != nil { return nil, err } if *storageDriver != "" { glog.Infof("Using backend storage type %q", *storageDriver) } glog.Infof("Caching stats in memory for %v", *storageDuration) return memory.New(*storageDuration, backendStorage), nil } cadvisor-0.25.0/summary/000077500000000000000000000000001306035727200151125ustar00rootroot00000000000000cadvisor-0.25.0/summary/buffer.go000066400000000000000000000036671306035727200167260ustar00rootroot00000000000000// Copyright 2015 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 summary import ( info "github.com/google/cadvisor/info/v2" ) // Manages a buffer of usage samples. // This is similar to stats buffer in cache/memory. // The main difference is that we do not pre-allocate the buffer as most containers // won't live that long. type SamplesBuffer struct { // list of collected samples. samples []info.Usage // maximum size this buffer can grow to. maxSize int // index for the latest sample. index int } // Initializes an empty buffer. func NewSamplesBuffer(size int) *SamplesBuffer { return &SamplesBuffer{ index: -1, maxSize: size, } } // Returns the current number of samples in the buffer. func (s *SamplesBuffer) Size() int { return len(s.samples) } // Add an element to the buffer. Oldest one is overwritten if required. func (s *SamplesBuffer) Add(stat info.Usage) { if len(s.samples) < s.maxSize { s.samples = append(s.samples, stat) s.index++ return } s.index = (s.index + 1) % s.maxSize s.samples[s.index] = stat } // Returns pointers to the last 'n' stats. func (s *SamplesBuffer) RecentStats(n int) []*info.Usage { if n > len(s.samples) { n = len(s.samples) } start := s.index - (n - 1) if start < 0 { start += len(s.samples) } out := make([]*info.Usage, n) for i := 0; i < n; i++ { index := (start + i) % len(s.samples) out[i] = &s.samples[index] } return out } cadvisor-0.25.0/summary/buffer_test.go000066400000000000000000000054161306035727200177570ustar00rootroot00000000000000// Copyright 2015 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 summary import ( "reflect" "testing" info "github.com/google/cadvisor/info/v2" ) func createSample(i uint64) info.Usage { usage := info.Usage{} usage.PercentComplete = 100 usage.Cpu = info.Percentiles{ Present: true, Mean: i * 50, Max: i * 100, Ninety: i * 90, } usage.Memory = info.Percentiles{ Present: true, Mean: i * 50 * 1024, Max: i * 100 * 1024, Ninety: i * 90 * 1024, } return usage } func expectSize(t *testing.T, b *SamplesBuffer, expectedSize int) { if b.Size() != expectedSize { t.Errorf("Expected size %d, got %d", expectedSize, b.Size()) } } func expectElements(t *testing.T, b *SamplesBuffer, expected []info.Usage) { out := b.RecentStats(b.Size()) if len(out) != len(expected) { t.Errorf("Expected %d elements, got %d", len(expected), len(out)) } for i, el := range out { if !reflect.DeepEqual(*el, expected[i]) { t.Errorf("Expected elements %v, got %v", expected[i], *el) } } } func TestEmpty(t *testing.T) { b := NewSamplesBuffer(5) expectSize(t, b, 0) expectElements(t, b, []info.Usage{}) } func TestAddSingleSample(t *testing.T) { b := NewSamplesBuffer(5) sample := createSample(1) b.Add(sample) expectSize(t, b, 1) expectElements(t, b, []info.Usage{sample}) } func TestFullBuffer(t *testing.T) { maxSize := 5 b := NewSamplesBuffer(maxSize) samples := []info.Usage{} for i := 0; i < maxSize; i++ { sample := createSample(uint64(i)) samples = append(samples, sample) b.Add(sample) } expectSize(t, b, maxSize) expectElements(t, b, samples) } func TestOverflow(t *testing.T) { maxSize := 5 overflow := 2 b := NewSamplesBuffer(maxSize) samples := []info.Usage{} for i := 0; i < maxSize+overflow; i++ { sample := createSample(uint64(i)) if i >= overflow { samples = append(samples, sample) } b.Add(sample) } expectSize(t, b, maxSize) expectElements(t, b, samples) } func TestReplaceAll(t *testing.T) { maxSize := 5 b := NewSamplesBuffer(maxSize) samples := []info.Usage{} for i := 0; i < maxSize*2; i++ { sample := createSample(uint64(i)) if i >= maxSize { samples = append(samples, sample) } b.Add(sample) } expectSize(t, b, maxSize) expectElements(t, b, samples) } cadvisor-0.25.0/summary/percentiles.go000066400000000000000000000123611306035727200177610ustar00rootroot00000000000000// Copyright 2015 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. // Utility methods to calculate percentiles. package summary import ( "fmt" "math" "sort" info "github.com/google/cadvisor/info/v2" ) const secondsToMilliSeconds = 1000 const milliSecondsToNanoSeconds = 1000000 const secondsToNanoSeconds = secondsToMilliSeconds * milliSecondsToNanoSeconds type Uint64Slice []uint64 func (a Uint64Slice) Len() int { return len(a) } func (a Uint64Slice) Swap(i, j int) { a[i], a[j] = a[j], a[i] } func (a Uint64Slice) Less(i, j int) bool { return a[i] < a[j] } // Get percentile of the provided samples. Round to integer. func (self Uint64Slice) GetPercentile(d float64) uint64 { if d < 0.0 || d > 1.0 { return 0 } count := self.Len() if count == 0 { return 0 } sort.Sort(self) n := float64(d * (float64(count) + 1)) idx, frac := math.Modf(n) index := int(idx) percentile := float64(self[index-1]) if index > 1 && index < count { percentile += frac * float64(self[index]-self[index-1]) } return uint64(percentile) } type mean struct { // current count. count uint64 // current mean. Mean float64 } func (self *mean) Add(value uint64) { self.count++ if self.count == 1 { self.Mean = float64(value) return } c := float64(self.count) v := float64(value) self.Mean = (self.Mean*(c-1) + v) / c } type resource struct { // list of samples being tracked. samples Uint64Slice // average from existing samples. mean mean // maximum value seen so far in the added samples. max uint64 } // Adds a new percentile sample. func (self *resource) Add(p info.Percentiles) { if !p.Present { return } if p.Max > self.max { self.max = p.Max } self.mean.Add(p.Mean) // Selecting 90p of 90p :( self.samples = append(self.samples, p.Ninety) } // Add a single sample. Internally, we convert it to a fake percentile sample. func (self *resource) AddSample(val uint64) { sample := info.Percentiles{ Present: true, Mean: val, Max: val, Fifty: val, Ninety: val, NinetyFive: val, } self.Add(sample) } // Get max, average, and 90p from existing samples. func (self *resource) GetAllPercentiles() info.Percentiles { p := info.Percentiles{} p.Mean = uint64(self.mean.Mean) p.Max = self.max p.Fifty = self.samples.GetPercentile(0.5) p.Ninety = self.samples.GetPercentile(0.9) p.NinetyFive = self.samples.GetPercentile(0.95) p.Present = true return p } func NewResource(size int) *resource { return &resource{ samples: make(Uint64Slice, 0, size), mean: mean{count: 0, Mean: 0}, } } // Return aggregated percentiles from the provided percentile samples. func GetDerivedPercentiles(stats []*info.Usage) info.Usage { cpu := NewResource(len(stats)) memory := NewResource(len(stats)) for _, stat := range stats { cpu.Add(stat.Cpu) memory.Add(stat.Memory) } usage := info.Usage{} usage.Cpu = cpu.GetAllPercentiles() usage.Memory = memory.GetAllPercentiles() return usage } // Calculate part of a minute this sample set represent. func getPercentComplete(stats []*secondSample) (percent int32) { numSamples := len(stats) if numSamples > 1 { percent = 100 timeRange := stats[numSamples-1].Timestamp.Sub(stats[0].Timestamp).Nanoseconds() // allow some slack if timeRange < 58*secondsToNanoSeconds { percent = int32((timeRange * 100) / 60 * secondsToNanoSeconds) } } return } // Calculate cpurate from two consecutive total cpu usage samples. func getCpuRate(latest, previous secondSample) (uint64, error) { var elapsed int64 elapsed = latest.Timestamp.Sub(previous.Timestamp).Nanoseconds() if elapsed < 10*milliSecondsToNanoSeconds { return 0, fmt.Errorf("elapsed time too small: %d ns: time now %s last %s", elapsed, latest.Timestamp.String(), previous.Timestamp.String()) } if latest.Cpu < previous.Cpu { return 0, fmt.Errorf("bad sample: cumulative cpu usage dropped from %d to %d", latest.Cpu, previous.Cpu) } // Cpurate is calculated in cpu-milliseconds per second. cpuRate := (latest.Cpu - previous.Cpu) * secondsToMilliSeconds / uint64(elapsed) return cpuRate, nil } // Returns a percentile sample for a minute by aggregating seconds samples. func GetMinutePercentiles(stats []*secondSample) info.Usage { lastSample := secondSample{} cpu := NewResource(len(stats)) memory := NewResource(len(stats)) for _, stat := range stats { if !lastSample.Timestamp.IsZero() { cpuRate, err := getCpuRate(*stat, lastSample) if err != nil { continue } cpu.AddSample(cpuRate) memory.AddSample(stat.Memory) } else { memory.AddSample(stat.Memory) } lastSample = *stat } percent := getPercentComplete(stats) return info.Usage{ PercentComplete: percent, Cpu: cpu.GetAllPercentiles(), Memory: memory.GetAllPercentiles(), } } cadvisor-0.25.0/summary/percentiles_test.go000066400000000000000000000122351306035727200210200ustar00rootroot00000000000000// Copyright 2015 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 summary import ( "testing" "time" info "github.com/google/cadvisor/info/v2" ) const Nanosecond = 1000000000 func assertPercentile(t *testing.T, s Uint64Slice, f float64, want uint64) { if got := s.GetPercentile(f); got != want { t.Errorf("GetPercentile(%f) is %d, should be %d.", f, got, want) } } func TestPercentile(t *testing.T) { N := 100 s := make(Uint64Slice, 0, N) for i := N; i > 0; i-- { s = append(s, uint64(i)) } assertPercentile(t, s, 0.2, 20) assertPercentile(t, s, 0.7, 70) assertPercentile(t, s, 0.9, 90) N = 105 for i := 101; i <= N; i++ { s = append(s, uint64(i)) } // 90p should be between 94 and 95. Promoted to 95. assertPercentile(t, s, 0.2, 21) assertPercentile(t, s, 0.7, 74) assertPercentile(t, s, 0.9, 95) } func TestMean(t *testing.T) { var i, N uint64 N = 100 mean := mean{count: 0, Mean: 0} for i = 1; i < N; i++ { mean.Add(i) } if mean.Mean != 50.0 { t.Errorf("Mean is %f, should be 50.0", mean.Mean) } } func TestAggregates(t *testing.T) { N := uint64(100) var i uint64 ct := time.Now() stats := make([]*secondSample, 0, N) for i = 1; i < N; i++ { s := &secondSample{ Timestamp: ct.Add(time.Duration(i) * time.Second), // cpu rate is 1 s/s Cpu: i * Nanosecond, // Memory grows by a KB every second. Memory: i * 1024, } stats = append(stats, s) } usage := GetMinutePercentiles(stats) // Cpu mean, max, and 90p should all be 1000 ms/s. cpuExpected := info.Percentiles{ Present: true, Mean: 1000, Max: 1000, Fifty: 1000, Ninety: 1000, NinetyFive: 1000, } if usage.Cpu != cpuExpected { t.Errorf("cpu stats are %+v. Expected %+v", usage.Cpu, cpuExpected) } memExpected := info.Percentiles{ Present: true, Mean: 50 * 1024, Max: 99 * 1024, Fifty: 50 * 1024, Ninety: 90 * 1024, NinetyFive: 95 * 1024, } if usage.Memory != memExpected { t.Errorf("memory stats are mean %+v. Expected %+v", usage.Memory, memExpected) } } func TestSamplesCloseInTimeIgnored(t *testing.T) { N := uint64(100) var i uint64 ct := time.Now() stats := make([]*secondSample, 0, N*2) for i = 1; i < N; i++ { s1 := &secondSample{ Timestamp: ct.Add(time.Duration(i) * time.Second), // cpu rate is 1 s/s Cpu: i * Nanosecond, // Memory grows by a KB every second. Memory: i * 1024, } stats = append(stats, s1) // Add another dummy sample too close in time to the last one. s2 := &secondSample{ // Add extra millisecond. Timestamp: ct.Add(time.Duration(i) * time.Second).Add(time.Duration(1) * time.Millisecond), Cpu: i * 100 * Nanosecond, Memory: i * 1024 * 1024, } stats = append(stats, s2) } usage := GetMinutePercentiles(stats) // Cpu mean, max, and 90p should all be 1000 ms/s. All high-value samples are discarded. cpuExpected := info.Percentiles{ Present: true, Mean: 1000, Max: 1000, Fifty: 1000, Ninety: 1000, NinetyFive: 1000, } if usage.Cpu != cpuExpected { t.Errorf("cpu stats are %+v. Expected %+v", usage.Cpu, cpuExpected) } memExpected := info.Percentiles{ Present: true, Mean: 50 * 1024, Max: 99 * 1024, Fifty: 50 * 1024, Ninety: 90 * 1024, NinetyFive: 95 * 1024, } if usage.Memory != memExpected { t.Errorf("memory stats are mean %+v. Expected %+v", usage.Memory, memExpected) } } func TestDerivedStats(t *testing.T) { N := uint64(100) var i uint64 stats := make([]*info.Usage, 0, N) for i = 1; i < N; i++ { s := &info.Usage{ PercentComplete: 100, Cpu: info.Percentiles{ Present: true, Mean: i * Nanosecond, Max: i * Nanosecond, Fifty: i * Nanosecond, Ninety: i * Nanosecond, NinetyFive: i * Nanosecond, }, Memory: info.Percentiles{ Present: true, Mean: i * 1024, Max: i * 1024, Fifty: i * 1024, Ninety: i * 1024, NinetyFive: i * 1024, }, } stats = append(stats, s) } usage := GetDerivedPercentiles(stats) cpuExpected := info.Percentiles{ Present: true, Mean: 50 * Nanosecond, Max: 99 * Nanosecond, Fifty: 50 * Nanosecond, Ninety: 90 * Nanosecond, NinetyFive: 95 * Nanosecond, } if usage.Cpu != cpuExpected { t.Errorf("cpu stats are %+v. Expected %+v", usage.Cpu, cpuExpected) } memExpected := info.Percentiles{ Present: true, Mean: 50 * 1024, Max: 99 * 1024, Fifty: 50 * 1024, Ninety: 90 * 1024, NinetyFive: 95 * 1024, } if usage.Memory != memExpected { t.Errorf("memory stats are mean %+v. Expected %+v", usage.Memory, memExpected) } } cadvisor-0.25.0/summary/summary.go000066400000000000000000000132251306035727200171410ustar00rootroot00000000000000// Copyright 2015 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. // Maintains the summary of aggregated minute, hour, and day stats. // For a container running for more than a day, amount of tracked data can go up to // 40 KB when cpu and memory are tracked. We'll start by enabling collection for the // node, followed by docker, and then all containers as we understand the usage pattern // better // TODO(rjnagal): Optimize the size if we start running it for every container. package summary import ( "fmt" "sync" "time" "github.com/google/cadvisor/info/v1" info "github.com/google/cadvisor/info/v2" ) // Usage fields we track for generating percentiles. type secondSample struct { Timestamp time.Time // time when the sample was recorded. Cpu uint64 // cpu usage Memory uint64 // memory usage } type availableResources struct { Cpu bool Memory bool } type StatsSummary struct { // Resources being tracked for this container. available availableResources // list of second samples. The list is cleared when a new minute samples is generated. secondSamples []*secondSample // minute percentiles. We track 24 * 60 maximum samples. minuteSamples *SamplesBuffer // latest derived instant, minute, hour, and day stats. Instant sample updated every second. // Others updated every minute. derivedStats info.DerivedStats // Guarded by dataLock. dataLock sync.RWMutex } // Adds a new seconds sample. // If enough seconds samples are collected, a minute sample is generated and derived // stats are updated. func (s *StatsSummary) AddSample(stat v1.ContainerStats) error { sample := secondSample{} sample.Timestamp = stat.Timestamp if s.available.Cpu { sample.Cpu = stat.Cpu.Usage.Total } if s.available.Memory { sample.Memory = stat.Memory.WorkingSet } s.secondSamples = append(s.secondSamples, &sample) s.updateLatestUsage() // TODO(jnagal): Use 'available' to avoid unnecessary computation. numSamples := len(s.secondSamples) elapsed := time.Nanosecond if numSamples > 1 { start := s.secondSamples[0].Timestamp end := s.secondSamples[numSamples-1].Timestamp elapsed = end.Sub(start) } if elapsed > 60*time.Second { // Make a minute sample. This works with dynamic housekeeping as long // as we keep max dynamic houskeeping period close to a minute. minuteSample := GetMinutePercentiles(s.secondSamples) // Clear seconds samples. Keep the latest sample for continuity. // Copying and resizing helps avoid slice re-allocation. s.secondSamples[0] = s.secondSamples[numSamples-1] s.secondSamples = s.secondSamples[:1] s.minuteSamples.Add(minuteSample) err := s.updateDerivedStats() if err != nil { return err } } return nil } func (s *StatsSummary) updateLatestUsage() { usage := info.InstantUsage{} numStats := len(s.secondSamples) if numStats < 1 { return } latest := s.secondSamples[numStats-1] usage.Memory = latest.Memory if numStats > 1 { previous := s.secondSamples[numStats-2] cpu, err := getCpuRate(*latest, *previous) if err == nil { usage.Cpu = cpu } } s.dataLock.Lock() defer s.dataLock.Unlock() s.derivedStats.LatestUsage = usage s.derivedStats.Timestamp = latest.Timestamp return } // Generate new derived stats based on current minute stats samples. func (s *StatsSummary) updateDerivedStats() error { derived := info.DerivedStats{} derived.Timestamp = time.Now() minuteSamples := s.minuteSamples.RecentStats(1) if len(minuteSamples) != 1 { return fmt.Errorf("failed to retrieve minute stats") } derived.MinuteUsage = *minuteSamples[0] hourUsage, err := s.getDerivedUsage(60) if err != nil { return fmt.Errorf("failed to compute hour stats: %v", err) } dayUsage, err := s.getDerivedUsage(60 * 24) if err != nil { return fmt.Errorf("failed to compute day usage: %v", err) } derived.HourUsage = hourUsage derived.DayUsage = dayUsage s.dataLock.Lock() defer s.dataLock.Unlock() derived.LatestUsage = s.derivedStats.LatestUsage s.derivedStats = derived return nil } // helper method to get hour and daily derived stats func (s *StatsSummary) getDerivedUsage(n int) (info.Usage, error) { if n < 1 { return info.Usage{}, fmt.Errorf("invalid number of samples requested: %d", n) } samples := s.minuteSamples.RecentStats(n) numSamples := len(samples) if numSamples < 1 { return info.Usage{}, fmt.Errorf("failed to retrieve any minute stats.") } // We generate derived stats even with partial data. usage := GetDerivedPercentiles(samples) // Assumes we have equally placed minute samples. usage.PercentComplete = int32(numSamples * 100 / n) return usage, nil } // Return the latest calculated derived stats. func (s *StatsSummary) DerivedStats() (info.DerivedStats, error) { s.dataLock.RLock() defer s.dataLock.RUnlock() return s.derivedStats, nil } func New(spec v1.ContainerSpec) (*StatsSummary, error) { summary := StatsSummary{} if spec.HasCpu { summary.available.Cpu = true } if spec.HasMemory { summary.available.Memory = true } if !summary.available.Cpu && !summary.available.Memory { return nil, fmt.Errorf("none of the resources are being tracked.") } summary.minuteSamples = NewSamplesBuffer(60 /* one hour */) return &summary, nil } cadvisor-0.25.0/test.htdigest000066400000000000000000000000611306035727200161260ustar00rootroot00000000000000admin:localhost:70f2631dded4ce5ad0ebbea5faa6ad6e cadvisor-0.25.0/test.htpasswd000066400000000000000000000000541306035727200161520ustar00rootroot00000000000000admin:$apr1$WVO0Bsre$VrmWGDbcBV1fdAkvgQwdk0 cadvisor-0.25.0/utils/000077500000000000000000000000001306035727200145555ustar00rootroot00000000000000cadvisor-0.25.0/utils/cloudinfo/000077500000000000000000000000001306035727200165375ustar00rootroot00000000000000cadvisor-0.25.0/utils/cloudinfo/aws.go000066400000000000000000000027241306035727200176650ustar00rootroot00000000000000// Copyright 2015 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 cloudinfo import ( "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/ec2metadata" "github.com/aws/aws-sdk-go/aws/session" "io/ioutil" "strings" info "github.com/google/cadvisor/info/v1" ) const ( ProductVerFileName = "/sys/class/dmi/id/product_version" Amazon = "amazon" ) func onAWS() bool { data, err := ioutil.ReadFile(ProductVerFileName) if err != nil { return false } return strings.Contains(string(data), Amazon) } func getAwsMetadata(name string) string { client := ec2metadata.New(session.New(&aws.Config{})) data, err := client.GetMetadata(name) if err != nil { return info.UnknownInstance } return data } func getAwsInstanceType() info.InstanceType { return info.InstanceType(getAwsMetadata("instance-type")) } func getAwsInstanceID() info.InstanceID { return info.InstanceID(getAwsMetadata("instance-id")) } cadvisor-0.25.0/utils/cloudinfo/azure.go000066400000000000000000000025241306035727200202170ustar00rootroot00000000000000// Copyright 2015 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 cloudinfo import ( info "github.com/google/cadvisor/info/v1" "io/ioutil" "strings" ) const ( SysVendorFileName = "/sys/class/dmi/id/sys_vendor" BiosUUIDFileName = "/sys/class/dmi/id/product_uuid" MicrosoftCorporation = "Microsoft Corporation" ) func onAzure() bool { data, err := ioutil.ReadFile(SysVendorFileName) if err != nil { return false } return strings.Contains(string(data), MicrosoftCorporation) } // TODO: Implement method. func getAzureInstanceType() info.InstanceType { return info.UnknownInstance } func getAzureInstanceID() info.InstanceID { data, err := ioutil.ReadFile(BiosUUIDFileName) if err != nil { return info.UnNamedInstance } return info.InstanceID(strings.TrimSuffix(string(data), "\n")) } cadvisor-0.25.0/utils/cloudinfo/cloudinfo.go000066400000000000000000000050021306035727200210450ustar00rootroot00000000000000// Copyright 2015 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. // Get information about the cloud provider (if any) cAdvisor is running on. package cloudinfo import ( info "github.com/google/cadvisor/info/v1" ) type CloudInfo interface { GetCloudProvider() info.CloudProvider GetInstanceType() info.InstanceType GetInstanceID() info.InstanceID } type realCloudInfo struct { cloudProvider info.CloudProvider instanceType info.InstanceType instanceID info.InstanceID } func NewRealCloudInfo() CloudInfo { cloudProvider := detectCloudProvider() instanceType := detectInstanceType(cloudProvider) instanceID := detectInstanceID(cloudProvider) return &realCloudInfo{ cloudProvider: cloudProvider, instanceType: instanceType, instanceID: instanceID, } } func (self *realCloudInfo) GetCloudProvider() info.CloudProvider { return self.cloudProvider } func (self *realCloudInfo) GetInstanceType() info.InstanceType { return self.instanceType } func (self *realCloudInfo) GetInstanceID() info.InstanceID { return self.instanceID } func detectCloudProvider() info.CloudProvider { switch { case onGCE(): return info.GCE case onAWS(): return info.AWS case onAzure(): return info.Azure case onBaremetal(): return info.Baremetal } return info.UnknownProvider } func detectInstanceType(cloudProvider info.CloudProvider) info.InstanceType { switch cloudProvider { case info.GCE: return getGceInstanceType() case info.AWS: return getAwsInstanceType() case info.Azure: return getAzureInstanceType() case info.Baremetal: return info.NoInstance } return info.UnknownInstance } func detectInstanceID(cloudProvider info.CloudProvider) info.InstanceID { switch cloudProvider { case info.GCE: return getGceInstanceID() case info.AWS: return getAwsInstanceID() case info.Azure: return getAzureInstanceID() case info.Baremetal: return info.UnNamedInstance } return info.UnNamedInstance } // TODO: Implement method. func onBaremetal() bool { return false } cadvisor-0.25.0/utils/cloudinfo/gce.go000066400000000000000000000031001306035727200176160ustar00rootroot00000000000000// Copyright 2015 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 cloudinfo import ( "io/ioutil" "strings" info "github.com/google/cadvisor/info/v1" "cloud.google.com/go/compute/metadata" "github.com/golang/glog" ) const ( gceProductName = "/sys/class/dmi/id/product_name" google = "Google" ) func onGCE() bool { data, err := ioutil.ReadFile(gceProductName) if err != nil { glog.V(2).Infof("Error while reading product_name: %v", err) return false } return strings.Contains(string(data), google) } func getGceInstanceType() info.InstanceType { machineType, err := metadata.Get("instance/machine-type") if err != nil { return info.UnknownInstance } responseParts := strings.Split(machineType, "/") // Extract the instance name from the machine type. return info.InstanceType(responseParts[len(responseParts)-1]) } func getGceInstanceID() info.InstanceID { instanceID, err := metadata.Get("instance/id") if err != nil { return info.UnknownInstance } return info.InstanceID(info.InstanceType(instanceID)) } cadvisor-0.25.0/utils/container/000077500000000000000000000000001306035727200165375ustar00rootroot00000000000000cadvisor-0.25.0/utils/container/container.go000066400000000000000000000020161306035727200210470ustar00rootroot00000000000000// Copyright 2016 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package container import ( info "github.com/google/cadvisor/info/v1" ) // Returns the alias a container is known by within a certain namespace, // if available. Otherwise returns the absolute name of the container. func GetPreferredName(ref info.ContainerReference) string { var containerName string if len(ref.Aliases) > 0 { containerName = ref.Aliases[0] } else { containerName = ref.Name } return containerName } cadvisor-0.25.0/utils/cpuload/000077500000000000000000000000001306035727200162045ustar00rootroot00000000000000cadvisor-0.25.0/utils/cpuload/cpuload.go000066400000000000000000000025551306035727200201710ustar00rootroot00000000000000// Copyright 2015 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 cpuload import ( "fmt" info "github.com/google/cadvisor/info/v1" "github.com/golang/glog" "github.com/google/cadvisor/utils/cpuload/netlink" ) type CpuLoadReader interface { // Start the reader. Start() error // Stop the reader and clean up internal state. Stop() // Retrieve Cpu load for a given group. // name is the full hierarchical name of the container. // Path is an absolute filesystem path for a container under CPU cgroup hierarchy. GetCpuLoad(name string, path string) (info.LoadStats, error) } func New() (CpuLoadReader, error) { reader, err := netlink.New() if err != nil { return nil, fmt.Errorf("failed to create a netlink based cpuload reader: %v", err) } glog.V(3).Info("Using a netlink-based load reader") return reader, nil } cadvisor-0.25.0/utils/cpuload/netlink/000077500000000000000000000000001306035727200176505ustar00rootroot00000000000000cadvisor-0.25.0/utils/cpuload/netlink/conn.go000066400000000000000000000045631306035727200211440ustar00rootroot00000000000000// Copyright 2015 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 netlink import ( "bufio" "bytes" "encoding/binary" "os" "syscall" ) type Connection struct { // netlink socket fd int // cache pid to use in every netlink request. pid uint32 // sequence number for netlink messages. seq uint32 addr syscall.SockaddrNetlink rbuf *bufio.Reader } // Create and bind a new netlink socket. func newConnection() (*Connection, error) { fd, err := syscall.Socket(syscall.AF_NETLINK, syscall.SOCK_DGRAM, syscall.NETLINK_GENERIC) if err != nil { return nil, err } conn := new(Connection) conn.fd = fd conn.seq = 0 conn.pid = uint32(os.Getpid()) conn.addr.Family = syscall.AF_NETLINK conn.rbuf = bufio.NewReader(conn) err = syscall.Bind(fd, &conn.addr) if err != nil { syscall.Close(fd) return nil, err } return conn, err } func (self *Connection) Read(b []byte) (n int, err error) { n, _, err = syscall.Recvfrom(self.fd, b, 0) return n, err } func (self *Connection) Write(b []byte) (n int, err error) { err = syscall.Sendto(self.fd, b, 0, &self.addr) return len(b), err } func (self *Connection) Close() error { return syscall.Close(self.fd) } func (self *Connection) WriteMessage(msg syscall.NetlinkMessage) error { w := bytes.NewBuffer(nil) msg.Header.Len = uint32(syscall.NLMSG_HDRLEN + len(msg.Data)) msg.Header.Seq = self.seq self.seq++ msg.Header.Pid = self.pid binary.Write(w, binary.LittleEndian, msg.Header) _, err := w.Write(msg.Data) if err != nil { return err } _, err = self.Write(w.Bytes()) return err } func (self *Connection) ReadMessage() (msg syscall.NetlinkMessage, err error) { err = binary.Read(self.rbuf, binary.LittleEndian, &msg.Header) if err != nil { return msg, err } msg.Data = make([]byte, msg.Header.Len-syscall.NLMSG_HDRLEN) _, err = self.rbuf.Read(msg.Data) return msg, err } cadvisor-0.25.0/utils/cpuload/netlink/defs.go000066400000000000000000000013741306035727200211250ustar00rootroot00000000000000// Copyright 2015 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 netlink /* #include */ import "C" type TaskStats C.struct_taskstats const ( __TASKSTATS_CMD_MAX = C.__TASKSTATS_CMD_MAX ) cadvisor-0.25.0/utils/cpuload/netlink/example/000077500000000000000000000000001306035727200213035ustar00rootroot00000000000000cadvisor-0.25.0/utils/cpuload/netlink/example/example.go000066400000000000000000000022051306035727200232640ustar00rootroot00000000000000// Copyright 2015 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 ( "log" "github.com/google/cadvisor/utils/cpuload/netlink" ) func main() { n, err := netlink.New() if err != nil { log.Printf("Failed to create cpu load util: %s", err) return } defer n.Stop() paths := []string{"/sys/fs/cgroup/cpu", "/sys/fs/cgroup/cpu/docker"} names := []string{"/", "/docker"} for i, path := range paths { stats, err := n.GetCpuLoad(names[i], path) if err != nil { log.Printf("Error getting cpu load for %q: %s", path, err) } log.Printf("Task load for %s: %+v", path, stats) } } cadvisor-0.25.0/utils/cpuload/netlink/netlink.go000066400000000000000000000152601306035727200216470ustar00rootroot00000000000000// Copyright 2015 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 netlink import ( "bytes" "encoding/binary" "fmt" "os" "syscall" info "github.com/google/cadvisor/info/v1" ) const ( // Kernel constants for tasks stats. genlIdCtrl = syscall.NLMSG_MIN_TYPE // GENL_ID_CTRL taskstatsGenlName = "TASKSTATS" // TASKSTATS_GENL_NAME cgroupStatsCmdAttrFd = 0x1 // CGROUPSTATS_CMD_ATTR_FD ctrlAttrFamilyId = 0x1 // CTRL_ATTR_FAMILY_ID ctrlAttrFamilyName = 0x2 // CTRL_ATTR_FAMILY_NAME ctrlCmdGetFamily = 0x3 // CTRL_CMD_GETFAMILY ) var ( // TODO(rjnagal): Verify and fix for other architectures. Endian = binary.LittleEndian ) type genMsghdr struct { Command uint8 Version uint8 Reserved uint16 } type netlinkMessage struct { Header syscall.NlMsghdr GenHeader genMsghdr Data []byte } func (self netlinkMessage) toRawMsg() (rawmsg syscall.NetlinkMessage) { rawmsg.Header = self.Header w := bytes.NewBuffer([]byte{}) binary.Write(w, Endian, self.GenHeader) w.Write(self.Data) rawmsg.Data = w.Bytes() return rawmsg } type loadStatsResp struct { Header syscall.NlMsghdr GenHeader genMsghdr Stats info.LoadStats } // Return required padding to align 'size' to 'alignment'. func padding(size int, alignment int) int { unalignedPart := size % alignment return (alignment - unalignedPart) % alignment } // Get family id for taskstats subsystem. func getFamilyId(conn *Connection) (uint16, error) { msg := prepareFamilyMessage() conn.WriteMessage(msg.toRawMsg()) resp, err := conn.ReadMessage() if err != nil { return 0, err } id, err := parseFamilyResp(resp) if err != nil { return 0, err } return id, nil } // Append an attribute to the message. // Adds attribute info (length and type), followed by the data and necessary padding. // Can be called multiple times to add attributes. Only fixed size and string type // attributes are handled. We don't need nested attributes for task stats. func addAttribute(buf *bytes.Buffer, attrType uint16, data interface{}, dataSize int) { attr := syscall.RtAttr{ Len: syscall.SizeofRtAttr, Type: attrType, } attr.Len += uint16(dataSize) binary.Write(buf, Endian, attr) switch data := data.(type) { case string: binary.Write(buf, Endian, []byte(data)) buf.WriteByte(0) // terminate default: binary.Write(buf, Endian, data) } for i := 0; i < padding(int(attr.Len), syscall.NLMSG_ALIGNTO); i++ { buf.WriteByte(0) } } // Prepares the message and generic headers and appends attributes as data. func prepareMessage(headerType uint16, cmd uint8, attributes []byte) (msg netlinkMessage) { msg.Header.Type = headerType msg.Header.Flags = syscall.NLM_F_REQUEST msg.GenHeader.Command = cmd msg.GenHeader.Version = 0x1 msg.Data = attributes return msg } // Prepares message to query family id for task stats. func prepareFamilyMessage() (msg netlinkMessage) { buf := bytes.NewBuffer([]byte{}) addAttribute(buf, ctrlAttrFamilyName, taskstatsGenlName, len(taskstatsGenlName)+1) return prepareMessage(genlIdCtrl, ctrlCmdGetFamily, buf.Bytes()) } // Prepares message to query task stats for a task group. func prepareCmdMessage(id uint16, cfd uintptr) (msg netlinkMessage) { buf := bytes.NewBuffer([]byte{}) addAttribute(buf, cgroupStatsCmdAttrFd, uint32(cfd), 4) return prepareMessage(id, __TASKSTATS_CMD_MAX+1, buf.Bytes()) } // Extracts returned family id from the response. func parseFamilyResp(msg syscall.NetlinkMessage) (uint16, error) { m := new(netlinkMessage) m.Header = msg.Header err := verifyHeader(msg) if err != nil { return 0, err } buf := bytes.NewBuffer(msg.Data) // extract generic header from data. err = binary.Read(buf, Endian, &m.GenHeader) if err != nil { return 0, err } id := uint16(0) // Extract attributes. kernel reports family name, id, version, etc. // Scan till we find id. for buf.Len() > syscall.SizeofRtAttr { var attr syscall.RtAttr err = binary.Read(buf, Endian, &attr) if err != nil { return 0, err } if attr.Type == ctrlAttrFamilyId { err = binary.Read(buf, Endian, &id) if err != nil { return 0, err } return id, nil } payload := int(attr.Len) - syscall.SizeofRtAttr skipLen := payload + padding(payload, syscall.SizeofRtAttr) name := make([]byte, skipLen) err = binary.Read(buf, Endian, name) if err != nil { return 0, err } } return 0, fmt.Errorf("family id not found in the response.") } // Extract task stats from response returned by kernel. func parseLoadStatsResp(msg syscall.NetlinkMessage) (*loadStatsResp, error) { m := new(loadStatsResp) m.Header = msg.Header err := verifyHeader(msg) if err != nil { return m, err } buf := bytes.NewBuffer(msg.Data) // Scan the general header. err = binary.Read(buf, Endian, &m.GenHeader) if err != nil { return m, err } // cgroup stats response should have just one attribute. // Read it directly into the stats structure. var attr syscall.RtAttr err = binary.Read(buf, Endian, &attr) if err != nil { return m, err } err = binary.Read(buf, Endian, &m.Stats) if err != nil { return m, err } return m, err } // Verify and return any error reported by kernel. func verifyHeader(msg syscall.NetlinkMessage) error { switch msg.Header.Type { case syscall.NLMSG_DONE: return fmt.Errorf("expected a response, got nil") case syscall.NLMSG_ERROR: buf := bytes.NewBuffer(msg.Data) var errno int32 binary.Read(buf, Endian, errno) return fmt.Errorf("netlink request failed with error %s", syscall.Errno(-errno)) } return nil } // Get load stats for a task group. // id: family id for taskstats. // cfd: open file to path to the cgroup directory under cpu hierarchy. // conn: open netlink connection used to communicate with kernel. func getLoadStats(id uint16, cfd *os.File, conn *Connection) (info.LoadStats, error) { msg := prepareCmdMessage(id, cfd.Fd()) err := conn.WriteMessage(msg.toRawMsg()) if err != nil { return info.LoadStats{}, err } resp, err := conn.ReadMessage() if err != nil { return info.LoadStats{}, err } parsedmsg, err := parseLoadStatsResp(resp) if err != nil { return info.LoadStats{}, err } return parsedmsg.Stats, nil } cadvisor-0.25.0/utils/cpuload/netlink/reader.go000066400000000000000000000042751306035727200214510ustar00rootroot00000000000000// Copyright 2015 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 netlink import ( "fmt" "os" info "github.com/google/cadvisor/info/v1" "github.com/golang/glog" ) type NetlinkReader struct { familyId uint16 conn *Connection } func New() (*NetlinkReader, error) { conn, err := newConnection() if err != nil { return nil, fmt.Errorf("failed to create a new connection: %s", err) } id, err := getFamilyId(conn) if err != nil { return nil, fmt.Errorf("failed to get netlink family id for task stats: %s", err) } glog.V(4).Infof("Family id for taskstats: %d", id) return &NetlinkReader{ familyId: id, conn: conn, }, nil } func (self *NetlinkReader) Stop() { if self.conn != nil { self.conn.Close() } } func (self *NetlinkReader) Start() error { // We do the start setup for netlink in New(). Nothing to do here. return nil } // Returns instantaneous number of running tasks in a group. // Caller can use historical data to calculate cpu load. // path is an absolute filesystem path for a container under the CPU cgroup hierarchy. // NOTE: non-hierarchical load is returned. It does not include load for subcontainers. func (self *NetlinkReader) GetCpuLoad(name string, path string) (info.LoadStats, error) { if len(path) == 0 { return info.LoadStats{}, fmt.Errorf("cgroup path can not be empty!") } cfd, err := os.Open(path) defer cfd.Close() if err != nil { return info.LoadStats{}, fmt.Errorf("failed to open cgroup path %s: %q", path, err) } stats, err := getLoadStats(self.familyId, cfd, self.conn) if err != nil { return info.LoadStats{}, err } glog.V(4).Infof("Task stats for %q: %+v", path, stats) return stats, nil } cadvisor-0.25.0/utils/docker/000077500000000000000000000000001306035727200160245ustar00rootroot00000000000000cadvisor-0.25.0/utils/docker/docker.go000066400000000000000000000034351306035727200176270ustar00rootroot00000000000000// Copyright 2016 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package docker import ( "fmt" "os" "strings" dockertypes "github.com/docker/engine-api/types" ) const ( DockerInfoDriver = "Driver" DockerInfoDriverStatus = "DriverStatus" DriverStatusPoolName = "Pool Name" DriverStatusDataLoopFile = "Data loop file" DriverStatusMetadataFile = "Metadata file" ) func DriverStatusValue(status [][2]string, target string) string { for _, v := range status { if strings.EqualFold(v[0], target) { return v[1] } } return "" } func DockerThinPoolName(info dockertypes.Info) (string, error) { poolName := DriverStatusValue(info.DriverStatus, DriverStatusPoolName) if len(poolName) == 0 { return "", fmt.Errorf("Could not get devicemapper pool name") } return poolName, nil } func DockerMetadataDevice(info dockertypes.Info) (string, error) { metadataDevice := DriverStatusValue(info.DriverStatus, DriverStatusMetadataFile) if len(metadataDevice) != 0 { return metadataDevice, nil } poolName, err := DockerThinPoolName(info) if err != nil { return "", err } metadataDevice = fmt.Sprintf("/dev/mapper/%s_tmeta", poolName) if _, err := os.Stat(metadataDevice); err != nil { return "", err } return metadataDevice, nil } cadvisor-0.25.0/utils/oomparser/000077500000000000000000000000001306035727200165645ustar00rootroot00000000000000cadvisor-0.25.0/utils/oomparser/containerOomExampleLog.txt000066400000000000000000000112451306035727200237430ustar00rootroot00000000000000Jan 5 15:19:01 CRON[14500]: (root) CMD (touch /var/run/crond.sittercheck) Jan 5 15:19:04 cookie_monster[1249]: uid 0, pid 14504, "/var/lib/certs/machine_cert.crt" accessed by exe "/usr/bin/nsscacheclient", cwd "/root", comm "/usr/bin/nsscacheclient" Jan 5 15:19:04 cookie_monster[1249]: uid 0, pid 14504, "/var/lib/certs/machine_cert.key" accessed by exe "/usr/bin/nsscacheclient", cwd "/root", comm "/usr/bin/nsscacheclient" Jan 5 15:19:05 nsscacheclient[14504]: SUCCESS: Completed run (v29/c20 rtime:0.334299 utime:0.136923 stime:0.011736 maxrss:5260k dials:1 sent:1793 rcvd:5143). Jan 5 15:19:27 kernel: [ 5864.708440] memorymonster invoked oom-killer: gfp_mask=0xd0, order=0, oom_score_adj=0 Jan 5 15:19:27 kernel: [ 5864.708443] memorymonster cpuset=/ mems_allowed=0 Jan 5 15:19:27 kernel: [ 5864.708446] CPU: 5 PID: 13536 Comm: memorymonster Tainted: P OX 3.13.0-43-generic #72-Ubuntu Jan 5 15:19:27 kernel: [ 5864.708447] Hardware name: Hewlett-Packard HP Z420 Workstation/1589, BIOS J61 v03.65 12/19/2013 Jan 5 15:19:27 kernel: [ 5864.708448] ffff88072ae10800 ffff8807a4835c48 ffffffff81720bf6 ffff8807a8e86000 Jan 5 15:19:27 kernel: [ 5864.708451] ffff8807a4835cd0 ffffffff8171b4b1 0000000000000246 ffff88072ae10800 Jan 5 15:19:27 kernel: [ 5864.708453] ffff8807a4835c90 ffff8807a4835ca0 ffffffff811522a7 0000000000000001 Jan 5 15:19:27 kernel: [ 5864.708455] Call Trace: Jan 5 15:19:27 kernel: [ 5864.708460] [] dump_stack+0x45/0x56 Jan 5 15:19:27 kernel: [ 5864.708463] [] dump_header+0x7f/0x1f1 Jan 5 15:19:27 kernel: [ 5864.708465] [] ? find_lock_task_mm+0x27/0x70 Jan 5 15:19:27 kernel: [ 5864.708467] [] oom_kill_process+0x1ce/0x330 Jan 5 15:19:27 kernel: [ 5864.708470] [] ? security_capable_noaudit+0x15/0x20 Jan 5 15:19:27 kernel: [ 5864.708474] [] mem_cgroup_oom_synchronize+0x51c/0x560 Jan 5 15:19:27 kernel: [ 5864.708476] [] ? mem_cgroup_charge_common+0xa0/0xa0 Jan 5 15:19:27 kernel: [ 5864.708478] [] pagefault_out_of_memory+0x14/0x80 Jan 5 15:19:27 kernel: [ 5864.708480] [] mm_fault_error+0x8e/0x180 Jan 5 15:19:27 kernel: [ 5864.708482] [] __do_page_fault+0x4a1/0x560 Jan 5 15:19:27 kernel: [ 5864.708485] [] ? set_next_entity+0x95/0xb0 Jan 5 15:19:27 kernel: [ 5864.708489] [] ? __switch_to+0x169/0x4c0 Jan 5 15:19:27 kernel: [ 5864.708490] [] do_page_fault+0x1a/0x70 Jan 5 15:19:27 kernel: [ 5864.708492] [] page_fault+0x28/0x30 Jan 5 15:19:27 kernel: [ 5864.708493] Task in /mem2 killed as a result of limit of /mem2 Jan 5 15:19:27 kernel: [ 5864.708495] memory: usage 980kB, limit 980kB, failcnt 4152239 Jan 5 15:19:27 kernel: [ 5864.708495] memory+swap: usage 0kB, limit 18014398509481983kB, failcnt 0 Jan 5 15:19:27 kernel: [ 5864.708496] kmem: usage 0kB, limit 18014398509481983kB, failcnt 0 Jan 5 15:19:27 kernel: [ 5864.708497] Memory cgroup stats for /mem2: cache:0KB rss:980KB rss_huge:0KB mapped_file:0KB writeback:20KB inactive_anon:560KB active_anon:420KB inactive_file:0KB active_file:0KB unevictable:0KB Jan 5 15:19:27 kernel: [ 5864.708505] [ pid ] uid tgid total_vm rss nr_ptes swapents oom_score_adj name Jan 5 15:19:27 kernel: [ 5864.708600] [13536] 275858 13536 8389663 343 16267 8324326 0 memorymonster Jan 5 15:19:27 kernel: [ 5864.708607] Memory cgroup out of memory: Kill process 13536 (memorymonster) score 996 or sacrifice child Jan 5 15:19:27 kernel: [ 5864.708608] Killed process 13536 (memorymonster) total-vm:33558652kB, anon-rss:920kB, file-rss:452kB Jan 5 15:20:01 CRON[14608]: (root) CMD (touch /var/run/crond.sittercheck) Jan 5 15:20:01 CRON[14609]: (root) CMD (/usr/bin/alarm 6000 /usr/share/update-notifier/reevaluate.py) Jan 5 15:20:01 CRON[14610]: (root) CMD (/usr/bin/corp_cronwrap -j 80 -t 600 -A -K -L -l 'nsscache-client' /usr/bin/nsscacheclient all) Jan 5 15:20:01 /usr/bin/lock: called by /bin/bash for . uid 0, euid 0. Jan 5 15:21:01 CRON[14639]: (root) CMD (touch /var/run/crond.sittercheck) Jan 5 15:21:05 cookie_monster[1249]: uid 0, pid 14643, "/var/lib/certs/machine_cert.crt" accessed by exe "/usr/bin/nsscacheclient", cwd "/root", comm "/usr/bin/nsscacheclient" Jan 5 15:21:05 cookie_monster[1249]: uid 0, pid 14643, "/var/lib/certs/machine_cert.key" accessed by exe "/usr/bin/nsscacheclient", cwd "/root", comm "/usr/bin/nsscacheclient" Jan 5 15:21:05 nsscacheclient[14643]: auto.auto(no change) time:0.042264697000000004 retries:0 Jan 5 15:21:05 nsscacheclient[14643]: auto.home(63c07d09->8686499b write:3631382) time:0.318774602 retries:0cadvisor-0.25.0/utils/oomparser/oomexample/000077500000000000000000000000001306035727200207325ustar00rootroot00000000000000cadvisor-0.25.0/utils/oomparser/oomexample/main.go000066400000000000000000000025261306035727200222120ustar00rootroot00000000000000// 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" "github.com/golang/glog" "github.com/google/cadvisor/utils/oomparser" ) // demonstrates how to run oomparser.OomParser to get OomInstance information func main() { flag.Parse() // out is a user-provided channel from which the user can read incoming // OomInstance objects outStream := make(chan *oomparser.OomInstance) oomLog, err := oomparser.New() if err != nil { glog.Infof("Couldn't make a new oomparser. %v", err) } else { go oomLog.StreamOoms(outStream) // demonstration of how to get oomLog's list of oomInstances or access // the user-declared oomInstance channel, here called outStream for oomInstance := range outStream { glog.Infof("Reading the buffer. Output is %v", oomInstance) } } } cadvisor-0.25.0/utils/oomparser/oomparser.go000066400000000000000000000144731306035727200211330ustar00rootroot00000000000000// 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 oomparser import ( "bufio" "fmt" "io" "os/exec" "path" "regexp" "strconv" "time" "github.com/google/cadvisor/utils" "github.com/google/cadvisor/utils/tail" "github.com/golang/glog" ) var ( containerRegexp = regexp.MustCompile(`Task in (.*) killed as a result of limit of (.*)`) lastLineRegexp = regexp.MustCompile(`(^[A-Z][a-z]{2} .*[0-9]{1,2} [0-9]{1,2}:[0-9]{2}:[0-9]{2}) .* Killed process ([0-9]+) \(([\w]+)\)`) firstLineRegexp = regexp.MustCompile(`invoked oom-killer:`) ) // struct to hold file from which we obtain OomInstances type OomParser struct { ioreader *bufio.Reader } // struct that contains information related to an OOM kill instance type OomInstance struct { // process id of the killed process Pid int // the name of the killed process ProcessName string // the time that the process was reported to be killed, // accurate to the minute TimeOfDeath time.Time // the absolute name of the container that OOMed ContainerName string // the absolute name of the container that was killed // due to the OOM. VictimContainerName string } // gets the container name from a line and adds it to the oomInstance. func getContainerName(line string, currentOomInstance *OomInstance) error { parsedLine := containerRegexp.FindStringSubmatch(line) if parsedLine == nil { return nil } currentOomInstance.ContainerName = path.Join("/", parsedLine[1]) currentOomInstance.VictimContainerName = path.Join("/", parsedLine[2]) return nil } // gets the pid, name, and date from a line and adds it to oomInstance func getProcessNamePid(line string, currentOomInstance *OomInstance) (bool, error) { reList := lastLineRegexp.FindStringSubmatch(line) if reList == nil { return false, nil } const longForm = "Jan _2 15:04:05 2006" stringYear := strconv.Itoa(time.Now().Year()) linetime, err := time.ParseInLocation(longForm, reList[1]+" "+stringYear, time.Local) if err != nil { return false, err } currentOomInstance.TimeOfDeath = linetime pid, err := strconv.Atoi(reList[2]) if err != nil { return false, err } currentOomInstance.Pid = pid currentOomInstance.ProcessName = reList[3] return true, nil } // uses regex to see if line is the start of a kernel oom log func checkIfStartOfOomMessages(line string) bool { potential_oom_start := firstLineRegexp.MatchString(line) if potential_oom_start { return true } return false } // reads the file and sends only complete lines over a channel to analyzeLines. // Should prevent EOF errors that occur when lines are read before being fully // written to the log. It reads line by line splitting on // the "\n" character. func readLinesFromFile(lineChannel chan string, ioreader *bufio.Reader) error { linefragment := "" var line string var err error for true { line, err = ioreader.ReadString('\n') if err != nil && err != io.EOF { glog.Errorf("exiting analyzeLinesHelper with error %v", err) close(lineChannel) break } if line == "" { time.Sleep(100 * time.Millisecond) continue } if err == nil { lineChannel <- linefragment + line linefragment = "" } else { // err == io.EOF linefragment += line } } return err } // Calls goroutine for readLinesFromFile, which feeds it complete lines. // Lines are checked against a regexp to check for the pid, process name, etc. // At the end of an oom message group, StreamOoms adds the new oomInstance to // oomLog func (self *OomParser) StreamOoms(outStream chan *OomInstance) { lineChannel := make(chan string, 10) go func() { readLinesFromFile(lineChannel, self.ioreader) }() for line := range lineChannel { in_oom_kernel_log := checkIfStartOfOomMessages(line) if in_oom_kernel_log { oomCurrentInstance := &OomInstance{ ContainerName: "/", } for line := range lineChannel { err := getContainerName(line, oomCurrentInstance) if err != nil { glog.Errorf("%v", err) } finished, err := getProcessNamePid(line, oomCurrentInstance) if err != nil { glog.Errorf("%v", err) } if finished { break } } outStream <- oomCurrentInstance } } glog.Infof("exiting analyzeLines. OOM events will not be reported.") } func callJournalctl() (io.ReadCloser, error) { cmd := exec.Command("journalctl", "-k", "-f") readcloser, err := cmd.StdoutPipe() if err != nil { return nil, err } if err := cmd.Start(); err != nil { return nil, err } return readcloser, err } func trySystemd() (*OomParser, error) { readcloser, err := callJournalctl() if err != nil { return nil, err } glog.Infof("oomparser using systemd") return &OomParser{ ioreader: bufio.NewReader(readcloser), }, nil } // List of possible kernel log files. These are prioritized in order so that // we will use the first one that is available. var kernelLogFiles = []string{"/var/log/kern.log", "/var/log/messages", "/var/log/syslog"} // looks for system files that contain kernel messages and if one is found, sets // the systemFile attribute of the OomParser object func getLogFile() (string, error) { for _, logFile := range kernelLogFiles { if utils.FileExists(logFile) { glog.Infof("OOM parser using kernel log file: %q", logFile) return logFile, nil } } return "", fmt.Errorf("unable to find any kernel log file available from our set: %v", kernelLogFiles) } func tryLogFile() (*OomParser, error) { logFile, err := getLogFile() if err != nil { return nil, err } tail, err := tail.NewTail(logFile) if err != nil { return nil, err } return &OomParser{ ioreader: bufio.NewReader(tail), }, nil } // initializes an OomParser object. Returns an OomParser object and an error. func New() (*OomParser, error) { parser, err := trySystemd() if err == nil { return parser, nil } parser, err = tryLogFile() if err == nil { return parser, nil } return nil, err } cadvisor-0.25.0/utils/oomparser/oomparser_test.go000066400000000000000000000141111306035727200221570ustar00rootroot00000000000000// Copyright 2015 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 oomparser import ( "bufio" "fmt" "os" "strconv" "testing" "time" "github.com/stretchr/testify/assert" ) const startLine = "Jan 21 22:01:49 localhost kernel: [62278.816267] ruby invoked oom-killer: gfp_mask=0x201da, order=0, oom_score_adj=0" const endLine = "Jan 21 22:01:49 localhost kernel: [62279.421192] Killed process 19667 (evilprogram2) total-vm:1460016kB, anon-rss:1414008kB, file-rss:4kB" const containerLine = "Jan 26 14:10:07 kateknister0.mtv.corp.google.com kernel: [1814368.465205] Task in /mem2 killed as a result of limit of /mem3" const containerLogFile = "containerOomExampleLog.txt" const systemLogFile = "systemOomExampleLog.txt" func createExpectedContainerOomInstance(t *testing.T) *OomInstance { const longForm = "Jan _2 15:04:05 2006" deathTime, err := time.ParseInLocation(longForm, fmt.Sprintf("Jan 5 15:19:27 %d", time.Now().Year()), time.Local) if err != nil { t.Fatalf("could not parse expected time when creating expected container oom instance. Had error %v", err) return nil } return &OomInstance{ Pid: 13536, ProcessName: "memorymonster", TimeOfDeath: deathTime, ContainerName: "/mem2", VictimContainerName: "/mem2", } } func createExpectedSystemOomInstance(t *testing.T) *OomInstance { const longForm = "Jan _2 15:04:05 2006" deathTime, err := time.ParseInLocation(longForm, fmt.Sprintf("Jan 28 19:58:45 %d", time.Now().Year()), time.Local) if err != nil { t.Fatalf("could not parse expected time when creating expected system oom instance. Had error %v", err) return nil } return &OomInstance{ Pid: 1532, ProcessName: "badsysprogram", TimeOfDeath: deathTime, ContainerName: "/", VictimContainerName: "", } } func TestGetContainerName(t *testing.T) { currentOomInstance := new(OomInstance) err := getContainerName(startLine, currentOomInstance) if err != nil { t.Errorf("bad line fed to getContainerName should yield no error, but had error %v", err) } if currentOomInstance.ContainerName != "" { t.Errorf("bad line fed to getContainerName yielded no container name but set it to %s", currentOomInstance.ContainerName) } err = getContainerName(containerLine, currentOomInstance) if err != nil { t.Errorf("container line fed to getContainerName should yield no error, but had error %v", err) } if currentOomInstance.ContainerName != "/mem2" { t.Errorf("getContainerName should have set containerName to /mem2, not %s", currentOomInstance.ContainerName) } if currentOomInstance.VictimContainerName != "/mem3" { t.Errorf("getContainerName should have set victimContainerName to /mem3, not %s", currentOomInstance.VictimContainerName) } } func TestGetProcessNamePid(t *testing.T) { currentOomInstance := new(OomInstance) couldParseLine, err := getProcessNamePid(startLine, currentOomInstance) if err != nil { t.Errorf("bad line fed to getProcessNamePid should yield no error, but had error %v", err) } if couldParseLine { t.Errorf("bad line fed to getProcessNamePid should return false but returned %v", couldParseLine) } const longForm = "Jan _2 15:04:05 2006" stringYear := strconv.Itoa(time.Now().Year()) correctTime, err := time.ParseInLocation(longForm, fmt.Sprintf("Jan 21 22:01:49 %s", stringYear), time.Local) couldParseLine, err = getProcessNamePid(endLine, currentOomInstance) if err != nil { t.Errorf("good line fed to getProcessNamePid should yield no error, but had error %v", err) } if !couldParseLine { t.Errorf("good line fed to getProcessNamePid should return true but returned %v", couldParseLine) } if currentOomInstance.ProcessName != "evilprogram2" { t.Errorf("getProcessNamePid should have set processName to evilprogram2, not %s", currentOomInstance.ProcessName) } if currentOomInstance.Pid != 19667 { t.Errorf("getProcessNamePid should have set PID to 19667, not %d", currentOomInstance.Pid) } if !correctTime.Equal(currentOomInstance.TimeOfDeath) { t.Errorf("getProcessNamePid should have set date to %v, not %v", correctTime, currentOomInstance.TimeOfDeath) } } func TestCheckIfStartOfMessages(t *testing.T) { couldParseLine := checkIfStartOfOomMessages(endLine) if couldParseLine { t.Errorf("bad line fed to checkIfStartOfMessages should return false but returned %v", couldParseLine) } couldParseLine = checkIfStartOfOomMessages(startLine) if !couldParseLine { t.Errorf("start line fed to checkIfStartOfMessages should return true but returned %v", couldParseLine) } } func TestStreamOomsContainer(t *testing.T) { expectedContainerOomInstance := createExpectedContainerOomInstance(t) helpTestStreamOoms(expectedContainerOomInstance, containerLogFile, t) } func TestStreamOomsSystem(t *testing.T) { expectedSystemOomInstance := createExpectedSystemOomInstance(t) helpTestStreamOoms(expectedSystemOomInstance, systemLogFile, t) } func helpTestStreamOoms(oomCheckInstance *OomInstance, sysFile string, t *testing.T) { outStream := make(chan *OomInstance) oomLog := mockOomParser(sysFile, t) timeout := make(chan bool, 1) go func() { time.Sleep(1 * time.Second) timeout <- true }() go oomLog.StreamOoms(outStream) select { case oomInstance := <-outStream: assert.Equal(t, oomCheckInstance, oomInstance) case <-timeout: t.Error( "timeout happened before oomInstance was found in test file") } } func mockOomParser(sysFile string, t *testing.T) *OomParser { file, err := os.Open(sysFile) if err != nil { t.Errorf("had an error opening file: %v", err) } return &OomParser{ ioreader: bufio.NewReader(file), } } cadvisor-0.25.0/utils/oomparser/systemOomExampleLog.txt000066400000000000000000000670611306035727200233140ustar00rootroot00000000000000[ 0.000000] SLUB: HWalign=64, Order=0-3, MinObjects=0, CPUs=1, Nodes=1 [ 0.000000] Hierarchical RCU implementation. [ 0.000000] RCU dyntick-idle grace-period acceleration is enabled. [ 0.000000] RCU restricting CPUs from NR_CPUS=256 to nr_cpu_ids=1. [ 0.000000] Offload RCU callbacks from all CPUs [ 0.000000] Offload RCU callbacks from CPUs: 0. [ 0.000000] NR_IRQS:16640 nr_irqs:256 16 [ 0.000000] Console: colour dummy device 80x25 [ 0.000000] console [ttyS0] enabled [ 0.000000] allocated 7340032 bytes of page_cgroup [ 0.000000] please try 'cgroup_disable=memory' option if you don't want memory cgroups [ 0.000000] tsc: Detected 2500.000 MHz processor [ 0.008000] Calibrating delay loop (skipped) preset value.. 5000.00 BogoMIPS (lpj=10000000) [ 0.008000] pid_max: default: 32768 minimum: 301 [ 0.008000] Security Framework initialized [ 0.008000] AppArmor: AppArmor initialized [ 0.008000] Yama: becoming mindful. [ 0.008200] Dentry cache hash table entries: 262144 (order: 9, 2097152 bytes) [ 0.011365] Inode-cache hash table entries: 131072 (order: 8, 1048576 bytes) [ 0.013066] Mount-cache hash table entries: 4096 (order: 3, 32768 bytes) [ 0.014030] Mountpoint-cache hash table entries: 4096 (order: 3, 32768 bytes) [ 0.016266] Initializing cgroup subsys memory [ 0.016898] Initializing cgroup subsys devices [ 0.017546] Initializing cgroup subsys freezer [ 0.018193] Initializing cgroup subsys blkio [ 0.018793] Initializing cgroup subsys perf_event [ 0.019416] Initializing cgroup subsys hugetlb [ 0.020067] Disabled fast string operations [ 0.020681] CPU: Physical Processor ID: 0 [ 0.021238] CPU: Processor Core ID: 0 [ 0.022587] mce: CPU supports 32 MCE banks [ 0.023260] Last level iTLB entries: 4KB 512, 2MB 0, 4MB 0 [ 0.023260] Last level dTLB entries: 4KB 512, 2MB 0, 4MB 0 [ 0.023260] tlb_flushall_shift: 6 [ 0.043758] Freeing SMP alternatives memory: 32K (ffffffff81e6c000 - ffffffff81e74000) [ 0.048361] ACPI: Core revision 20131115 [ 0.049516] ACPI: All ACPI Tables successfully acquired [ 0.050342] ftrace: allocating 28458 entries in 112 pages [ 0.060327] Enabling x2apic [ 0.060740] Enabled x2apic [ 0.064005] Switched APIC routing to physical x2apic. [ 0.065489] ..TIMER: vector=0x30 apic1=0 pin1=0 apic2=-1 pin2=-1 [ 0.066331] smpboot: CPU0: Intel(R) Xeon(R) CPU @ 2.50GHz (fam: 06, model: 3e, stepping: 04) [ 0.072000] APIC calibration not consistent with PM-Timer: 227ms instead of 100ms [ 0.072000] APIC delta adjusted to PM-Timer: 6250028 (14249259) [ 0.074382] Performance Events: unsupported p6 CPU model 62 no PMU driver, software events only. [ 0.077174] x86: Booted up 1 node, 1 CPUs [ 0.077738] smpboot: Total of 1 processors activated (5000.00 BogoMIPS) [ 0.078932] NMI watchdog: disabled (cpu0): hardware events not enabled [ 0.079945] devtmpfs: initialized [ 0.081784] EVM: security.selinux [ 0.082251] EVM: security.SMACK64 [ 0.082720] EVM: security.ima [ 0.083135] EVM: security.capability [ 0.084729] pinctrl core: initialized pinctrl subsystem [ 0.085517] regulator-dummy: no parameters [ 0.086187] RTC time: 19:51:09, date: 01/28/15 [ 0.086869] NET: Registered protocol family 16 [ 0.087613] cpuidle: using governor ladder [ 0.088009] cpuidle: using governor menu [ 0.088580] ACPI: bus type PCI registered [ 0.089191] acpiphp: ACPI Hot Plug PCI Controller Driver version: 0.5 [ 0.090220] PCI: Using configuration type 1 for base access [ 0.091749] bio: create slab at 0 [ 0.092215] ACPI: Added _OSI(Module Device) [ 0.092799] ACPI: Added _OSI(Processor Device) [ 0.093410] ACPI: Added _OSI(3.0 _SCP Extensions) [ 0.094173] ACPI: Added _OSI(Processor Aggregator Device) [ 0.096962] ACPI: Interpreter enabled [ 0.097483] ACPI Exception: AE_NOT_FOUND, While evaluating Sleep State [\_S1_] (20131115/hwxface-580) [ 0.098762] ACPI Exception: AE_NOT_FOUND, While evaluating Sleep State [\_S2_] (20131115/hwxface-580) [ 0.100011] ACPI: (supports S0 S3 S4 S5) [ 0.100555] ACPI: Using IOAPIC for interrupt routing [ 0.101252] PCI: Using host bridge windows from ACPI; if necessary, use "pci=nocrs" and report a bug [ 0.102545] ACPI: No dock devices found. [ 0.105210] ACPI: PCI Root Bridge [PCI0] (domain 0000 [bus 00-ff]) [ 0.106060] acpi PNP0A03:00: _OSC: OS supports [ASPM ClockPM Segments MSI] [ 0.108025] acpi PNP0A03:00: _OSC failed (AE_NOT_FOUND); disabling ASPM [ 0.109116] acpi PNP0A03:00: fail to add MMCONFIG information, can't access extended PCI configuration space under this bridge. [ 0.112685] PCI host bridge to bus 0000:00 [ 0.113294] pci_bus 0000:00: root bus resource [bus 00-ff] [ 0.114054] pci_bus 0000:00: root bus resource [io 0x0000-0x0cf7] [ 0.115065] pci_bus 0000:00: root bus resource [io 0x0d00-0xffff] [ 0.116004] pci_bus 0000:00: root bus resource [mem 0x000a0000-0x000bffff] [ 0.116955] pci_bus 0000:00: root bus resource [mem 0x6cc00000-0xfebfffff] [ 0.117916] pci 0000:00:01.0: [8086:7110] type 00 class 0x060100 [ 0.122089] pci 0000:00:01.3: [8086:7113] type 00 class 0x068000 [ 0.125713] pci 0000:00:01.3: quirk: [io 0xb000-0xb03f] claimed by PIIX4 ACPI [ 0.127117] pci 0000:00:03.0: [1af4:1004] type 00 class 0x000000 [ 0.128752] pci 0000:00:03.0: reg 0x10: [io 0xc000-0xc03f] [ 0.130322] pci 0000:00:03.0: reg 0x14: [mem 0xfebfe000-0xfebfe07f] [ 0.133571] pci 0000:00:04.0: [1af4:1000] type 00 class 0x020000 [ 0.135267] pci 0000:00:04.0: reg 0x10: [io 0xc040-0xc07f] [ 0.136777] pci 0000:00:04.0: reg 0x14: [mem 0xfebff000-0xfebff03f] [ 0.140811] ACPI: PCI Interrupt Link [LNKA] (IRQs 5 *10 11) [ 0.141879] ACPI: PCI Interrupt Link [LNKB] (IRQs 5 *10 11) [ 0.142886] ACPI: PCI Interrupt Link [LNKC] (IRQs 5 10 *11) [ 0.144086] ACPI: PCI Interrupt Link [LNKD] (IRQs 5 10 *11) [ 0.145067] ACPI: PCI Interrupt Link [LNKS] (IRQs *9) [ 0.146245] ACPI: Enabled 16 GPEs in block 00 to 0F [ 0.147038] ACPI: \_SB_.PCI0: notify handler is installed [ 0.147840] Found 1 acpi root devices [ 0.148136] vgaarb: loaded [ 0.148780] SCSI subsystem initialized [ 0.149472] libata version 3.00 loaded. [ 0.150070] ACPI: bus type USB registered [ 0.150659] usbcore: registered new interface driver usbfs [ 0.151536] usbcore: registered new interface driver hub [ 0.152055] usbcore: registered new device driver usb [ 0.153144] PCI: Using ACPI for IRQ routing [ 0.153756] PCI: pci_cache_line_size set to 64 bytes [ 0.154617] e820: reserve RAM buffer [mem 0x0009fc00-0x0009ffff] [ 0.156004] e820: reserve RAM buffer [mem 0x6cbfe000-0x6fffffff] [ 0.156993] NetLabel: Initializing [ 0.157498] NetLabel: domain hash size = 128 [ 0.158082] NetLabel: protocols = UNLABELED CIPSOv4 [ 0.158815] NetLabel: unlabeled traffic allowed by default [ 0.160005] Switched to clocksource kvm-clock [ 0.168695] AppArmor: AppArmor Filesystem Enabled [ 0.169361] pnp: PnP ACPI init [ 0.169853] ACPI: bus type PNP registered [ 0.170499] pnp 00:00: Plug and Play ACPI device, IDs PNP0b00 (active) [ 0.171591] pnp 00:01: Plug and Play ACPI device, IDs PNP0501 (active) [ 0.172574] pnp 00:02: Plug and Play ACPI device, IDs PNP0501 (active) [ 0.173782] pnp: PnP ACPI: found 3 devices [ 0.174430] ACPI: bus type PNP unregistered [ 0.181364] pci_bus 0000:00: resource 4 [io 0x0000-0x0cf7] [ 0.182172] pci_bus 0000:00: resource 5 [io 0x0d00-0xffff] [ 0.183049] pci_bus 0000:00: resource 6 [mem 0x000a0000-0x000bffff] [ 0.184120] pci_bus 0000:00: resource 7 [mem 0x6cc00000-0xfebfffff] [ 0.185051] NET: Registered protocol family 2 [ 0.185859] TCP established hash table entries: 16384 (order: 5, 131072 bytes) [ 0.187117] TCP bind hash table entries: 16384 (order: 6, 262144 bytes) [ 0.188393] TCP: Hash tables configured (established 16384 bind 16384) [ 0.189429] TCP: reno registered [ 0.189929] UDP hash table entries: 1024 (order: 3, 32768 bytes) [ 0.190824] UDP-Lite hash table entries: 1024 (order: 3, 32768 bytes) [ 0.191830] NET: Registered protocol family 1 [ 0.192585] PCI: CLS 0 bytes, default 64 [ 0.193412] Trying to unpack rootfs image as initramfs... [ 0.897565] Freeing initrd memory: 18780K (ffff880035b42000 - ffff880036d99000) [ 0.898982] microcode: CPU0 sig=0x306e4, pf=0x1, revision=0x1 [ 0.899884] microcode: Microcode Update Driver: v2.00 , Peter Oruba [ 0.901196] Scanning for low memory corruption every 60 seconds [ 0.902497] Initialise system trusted keyring [ 0.903169] audit: initializing netlink socket (disabled) [ 0.904016] type=2000 audit(1422474669.702:1): initialized [ 0.926617] HugeTLB registered 2 MB page size, pre-allocated 0 pages [ 0.928567] zbud: loaded [ 0.929030] VFS: Disk quotas dquot_6.5.2 [ 0.929685] Dquot-cache hash table entries: 512 (order 0, 4096 bytes) [ 0.931113] fuse init (API version 7.22) [ 0.931781] msgmni has been set to 3390 [ 0.932595] Key type big_key registered [ 0.933680] Key type asymmetric registered [ 0.934332] Asymmetric key parser 'x509' registered [ 0.935078] Block layer SCSI generic (bsg) driver version 0.4 loaded (major 252) [ 0.936224] io scheduler noop registered [ 0.936858] io scheduler deadline registered (default) [ 0.937675] io scheduler cfq registered [ 0.938307] pci_hotplug: PCI Hot Plug PCI Core version: 0.5 [ 0.939158] pciehp: PCI Express Hot Plug Controller Driver version: 0.4 [ 0.940239] efifb: probing for efifb [ 0.940788] efifb: framebuffer at 0xa0000, mapped to 0xffff8800000a0000, using 64k, total 64k [ 0.942044] efifb: mode is 640x480x1, linelength=80, pages=1 [ 0.942964] efifb: scrolling: redraw [ 0.943525] efifb: Truecolor: size=8:8:8:8, shift=24:16:8:0 [ 0.945209] Console: switching to colour frame buffer device 80x30 [ 0.946826] fb0: EFI VGA frame buffer device [ 0.947485] intel_idle: does not run on family 6 model 62 [ 0.948380] ipmi message handler version 39.2 [ 0.949036] input: Power Button as /devices/LNXSYSTM:00/LNXPWRBN:00/input/input0 [ 0.950135] ACPI: Power Button [PWRF] [ 0.950722] input: Sleep Button as /devices/LNXSYSTM:00/LNXSLPBN:00/input/input1 [ 0.951773] ACPI: Sleep Button [SLPF] [ 0.952529] GHES: HEST is not enabled! [ 0.953921] ACPI: PCI Interrupt Link [LNKC] enabled at IRQ 11 [ 0.955783] ACPI: PCI Interrupt Link [LNKD] enabled at IRQ 10 [ 0.957395] Serial: 8250/16550 driver, 32 ports, IRQ sharing enabled [ 1.112167] 00:01: ttyS0 at I/O 0x3f8 (irq = 4, base_baud = 115200) is a 16550A [ 1.134843] 00:02: ttyS1 at I/O 0x2f8 (irq = 3, base_baud = 115200) is a 16550A [ 1.137110] Linux agpgart interface v0.103 [ 1.138975] brd: module loaded [ 1.140117] loop: module loaded [ 1.140923] libphy: Fixed MDIO Bus: probed [ 1.141640] tun: Universal TUN/TAP device driver, 1.6 [ 1.142342] tun: (C) 1999-2004 Max Krasnyansky [ 1.144063] virtio-pci 0000:00:04.0: irq 40 for MSI/MSI-X [ 1.144871] virtio-pci 0000:00:04.0: irq 41 for MSI/MSI-X [ 1.145670] virtio-pci 0000:00:04.0: irq 42 for MSI/MSI-X [ 1.151673] PPP generic driver version 2.4.2 [ 1.152344] ehci_hcd: USB 2.0 'Enhanced' Host Controller (EHCI) Driver [ 1.153399] ehci-pci: EHCI PCI platform driver [ 1.154021] ehci-platform: EHCI generic platform driver [ 1.154939] ohci_hcd: USB 1.1 'Open' Host Controller (OHCI) Driver [ 1.155973] ohci-pci: OHCI PCI platform driver [ 1.156675] ohci-platform: OHCI generic platform driver [ 1.157423] uhci_hcd: USB Universal Host Controller Interface driver [ 1.158352] i8042: PNP: No PS/2 controller found. Probing ports directly. [ 3.646820] i8042: No controller found [ 3.647493] tsc: Refined TSC clocksource calibration: 2500.002 MHz [ 3.648490] mousedev: PS/2 mouse device common for all mice [ 3.649499] rtc_cmos 00:00: RTC can wake from S4 [ 3.650595] rtc_cmos 00:00: rtc core: registered rtc_cmos as rtc0 [ 3.651521] rtc_cmos 00:00: alarms up to one day, 114 bytes nvram [ 3.652422] device-mapper: uevent: version 1.0.3 [ 3.653131] device-mapper: ioctl: 4.27.0-ioctl (2013-10-30) initialised: dm-devel@redhat.com [ 3.654281] ledtrig-cpu: registered to indicate activity on CPUs [ 3.655182] TCP: cubic registered [ 3.655704] NET: Registered protocol family 10 [ 3.656551] NET: Registered protocol family 17 [ 3.657183] Key type dns_resolver registered [ 3.657931] Loading compiled-in X.509 certificates [ 3.659264] Loaded X.509 cert 'Magrathea: Glacier signing key: 23984ac203784325ccf7b95b51f6c119380eb933' [ 3.660726] registered taskstats version 1 [ 3.663211] Key type trusted registered [ 3.665462] Key type encrypted registered [ 3.667679] AppArmor: AppArmor sha1 policy hashing enabled [ 3.668454] IMA: No TPM chip found, activating TPM-bypass! [ 3.669388] regulator-dummy: disabling [ 3.669971] Magic number: 15:428:901 [ 3.670625] clocksource clocksource0: hash matches [ 3.671311] acpi PNP0501:01: hash matches [ 3.671953] rtc_cmos 00:00: setting system clock to 2015-01-28 19:51:13 UTC (1422474673) [ 3.673268] BIOS EDD facility v0.16 2004-Jun-25, 0 devices found [ 3.674088] EDD information not available. [ 3.674668] PM: Hibernation image not present or could not be loaded. [ 3.676577] Freeing unused kernel memory: 1332K (ffffffff81d1f000 - ffffffff81e6c000) [ 3.678370] Write protecting the kernel read-only data: 12288k [ 3.681251] Freeing unused kernel memory: 828K (ffff880001731000 - ffff880001800000) [ 3.684444] Freeing unused kernel memory: 700K (ffff880001b51000 - ffff880001c00000) [ 3.700162] systemd-udevd[90]: starting version 204 [ 3.866262] virtio-pci 0000:00:03.0: irq 43 for MSI/MSI-X [ 3.867187] virtio-pci 0000:00:03.0: irq 44 for MSI/MSI-X [ 3.867997] virtio-pci 0000:00:03.0: irq 45 for MSI/MSI-X [ 3.876214] virtio-pci 0000:00:03.0: irq 46 for MSI/MSI-X [ 3.880005] scsi0 : Virtio SCSI HBA [ 3.912410] scsi 0:0:1:0: Direct-Access Google PersistentDisk 1 PQ: 0 ANSI: 6 [ 3.938957] sd 0:0:1:0: Attached scsi generic sg0 type 0 [ 3.939845] sd 0:0:1:0: [sda] 20971520 512-byte logical blocks: (10.7 GB/10.0 GiB) [ 3.941149] sd 0:0:1:0: [sda] 4096-byte physical blocks [ 3.942233] sd 0:0:1:0: [sda] Write Protect is off [ 3.942988] sd 0:0:1:0: [sda] Mode Sense: 1f 00 00 08 [ 3.944398] sd 0:0:1:0: [sda] Write cache: enabled, read cache: enabled, doesn't support DPO or FUA [ 3.961885] sda: sda1 [ 3.963152] sd 0:0:1:0: [sda] Attached SCSI disk [ 4.414649] EXT4-fs (sda1): mounted filesystem with ordered data mode. Opts: (null) [ 5.293574] random: init urandom read with 73 bits of entropy available [ 6.418187] random: nonblocking pool is initialized [ 6.692508] EXT4-fs (sda1): re-mounted. Opts: errors=remount-ro [ 7.121847] IPv6: ADDRCONF(NETDEV_UP): eth0: link is not ready [ 7.681714] systemd-udevd[293]: starting version 204 [ 8.437234] lp: driver loaded but no devices found [ 9.164195] piix4_smbus 0000:00:01.3: SMBus base address uninitialized - upgrade BIOS or use force_addr=0xaddr [ 9.648096] device-mapper: multipath: version 1.6.0 loaded [ 10.434575] type=1400 audit(1422474680.256:2): apparmor="STATUS" operation="profile_load" profile="unconfined" name="/sbin/dhclient" pid=368 comm="apparmor_parser" [ 10.437242] type=1400 audit(1422474680.260:3): apparmor="STATUS" operation="profile_load" profile="unconfined" name="/usr/lib/NetworkManager/nm-dhcp-client.action" pid=368 comm="apparmor_parser" [ 10.439901] type=1400 audit(1422474680.260:4): apparmor="STATUS" operation="profile_load" profile="unconfined" name="/usr/lib/connman/scripts/dhclient-script" pid=368 comm="apparmor_parser" [ 11.126295] type=1400 audit(1422474680.948:5): apparmor="STATUS" operation="profile_replace" profile="unconfined" name="/sbin/dhclient" pid=412 comm="apparmor_parser" [ 11.129123] type=1400 audit(1422474680.952:6): apparmor="STATUS" operation="profile_replace" profile="unconfined" name="/usr/lib/NetworkManager/nm-dhcp-client.action" pid=412 comm="apparmor_parser" [ 11.132139] type=1400 audit(1422474680.956:7): apparmor="STATUS" operation="profile_replace" profile="unconfined" name="/usr/lib/connman/scripts/dhclient-script" pid=412 comm="apparmor_parser" [ 11.196173] type=1400 audit(1422474681.020:8): apparmor="STATUS" operation="profile_replace" profile="unconfined" name="/sbin/dhclient" pid=458 comm="apparmor_parser" [ 11.198887] type=1400 audit(1422474681.020:9): apparmor="STATUS" operation="profile_replace" profile="unconfined" name="/usr/lib/NetworkManager/nm-dhcp-client.action" pid=458 comm="apparmor_parser" [ 11.201484] type=1400 audit(1422474681.028:10): apparmor="STATUS" operation="profile_replace" profile="unconfined" name="/usr/lib/connman/scripts/dhclient-script" pid=458 comm="apparmor_parser" [ 11.361371] init: udev-fallback-graphics main process (454) terminated with status 1 [ 11.378437] type=1400 audit(1422474681.200:11): apparmor="STATUS" operation="profile_replace" profile="unconfined" name="/usr/lib/NetworkManager/nm-dhcp-client.action" pid=458 comm="apparmor_parser" [ 14.366411] init: failsafe main process (491) killed by TERM signal kateknister@kateknister-test3:~$ tail -f /var/log/syslog Jan 28 19:51:47 localhost ntpdate[1240]: adjust time server 169.254.169.254 offset -0.383723 sec Jan 28 19:51:47 localhost ntpd[1312]: ntpd 4.2.6p5@1.2349-o Wed Oct 9 19:08:06 UTC 2013 (1) Jan 28 19:51:47 localhost ntpd[1313]: proto: precision = 0.449 usec Jan 28 19:51:47 localhost ntpd[1313]: ntp_io: estimated max descriptors: 1024, initial socket boundary: 16 Jan 28 19:51:47 localhost ntpd[1313]: Listen and drop on 0 v4wildcard 0.0.0.0 UDP 123 Jan 28 19:51:47 localhost ntpd[1313]: Listen and drop on 1 v6wildcard :: UDP 123 Jan 28 19:51:47 localhost ntpd[1313]: Listen normally on 2 lo 127.0.0.1 UDP 123 Jan 28 19:51:47 localhost ntpd[1313]: Listen normally on 3 eth0 10.240.192.196 UDP 123 Jan 28 19:51:47 localhost ntpd[1313]: peers refreshed Jan 28 19:51:47 localhost ntpd[1313]: Listening on routing socket on fd #20 for interface updates Jan 28 19:58:45 localhost kernel: [ 455.498827] badsysprogram invoked oom-killer: gfp_mask=0x280da, order=0, oom_score_adj=0 Jan 28 19:58:45 localhost kernel: [ 455.500173] badsysprogram cpuset=/ mems_allowed=0 Jan 28 19:58:45 localhost kernel: [ 455.501007] CPU: 0 PID: 1532 Comm: badsysprogram Not tainted 3.13.0-27-generic #50-Ubuntu Jan 28 19:58:45 localhost kernel: [ 455.502301] Hardware name: Google Google, BIOS Google 01/01/2011 Jan 28 19:58:45 localhost kernel: [ 455.503298] 0000000000000000 ffff880069715a90 ffffffff817199c4 ffff8800680d8000 Jan 28 19:58:45 localhost kernel: [ 455.504563] ffff880069715b18 ffffffff817142ff 0000000000000000 0000000000000000 Jan 28 19:58:45 localhost kernel: [ 455.505779] 0000000000000000 0000000000000000 0000000000000000 0000000000000000 Jan 28 19:58:45 localhost kernel: [ 455.506971] Call Trace: Jan 28 19:58:45 localhost kernel: [ 455.507353] [] dump_stack+0x45/0x56 Jan 28 19:58:45 localhost kernel: [ 455.508289] [] dump_header+0x7f/0x1f1 Jan 28 19:58:45 localhost kernel: [ 455.509112] [] oom_kill_process+0x1ce/0x330 Jan 28 19:58:45 localhost kernel: [ 455.510023] [] ? security_capable_noaudit+0x15/0x20 Jan 28 19:58:45 localhost kernel: [ 455.510994] [] out_of_memory+0x414/0x450 Jan 28 19:58:45 localhost kernel: [ 455.511820] [] __alloc_pages_nodemask+0xa87/0xb20 Jan 28 19:58:45 localhost kernel: [ 455.512815] [] alloc_pages_vma+0x9a/0x140 Jan 28 19:58:45 localhost kernel: [ 455.513647] [] handle_mm_fault+0xb2b/0xf10 Jan 28 19:58:45 localhost kernel: [ 455.514498] [] __do_page_fault+0x184/0x560 Jan 28 19:58:45 localhost kernel: [ 455.515415] [] ? sched_clock+0x9/0x10 Jan 28 19:58:45 localhost kernel: [ 455.516318] [] ? sched_clock_local+0x1d/0x80 Jan 28 19:58:45 localhost kernel: [ 455.517242] [] ? acct_account_cputime+0x1c/0x20 Jan 28 19:58:45 localhost kernel: [ 455.518141] [] ? account_user_time+0x8b/0xa0 Jan 28 19:58:45 localhost kernel: [ 455.519014] [] ? vtime_account_user+0x54/0x60 Jan 28 19:58:45 localhost kernel: [ 455.519910] [] do_page_fault+0x1a/0x70 Jan 28 19:58:45 localhost kernel: [ 455.520712] [] page_fault+0x28/0x30 Jan 28 19:58:45 localhost kernel: [ 455.521498] Mem-Info: Jan 28 19:58:45 localhost kernel: [ 455.521873] Node 0 DMA per-cpu: Jan 28 19:58:45 localhost kernel: [ 455.522388] CPU 0: hi: 0, btch: 1 usd: 0 Jan 28 19:58:45 localhost kernel: [ 455.598342] Node 0 DMA32 per-cpu: Jan 28 19:58:45 localhost kernel: [ 455.598890] CPU 0: hi: 186, btch: 31 usd: 86 Jan 28 19:58:45 localhost kernel: [ 455.599687] active_anon:405991 inactive_anon:57 isolated_anon:0 Jan 28 19:58:45 localhost kernel: [ 455.599687] active_file:35 inactive_file:69 isolated_file:0 Jan 28 19:58:45 localhost kernel: [ 455.599687] unevictable:0 dirty:0 writeback:0 unstable:0 Jan 28 19:58:45 localhost kernel: [ 455.599687] free:12929 slab_reclaimable:1635 slab_unreclaimable:1919 Jan 28 19:58:45 localhost kernel: [ 455.599687] mapped:34 shmem:70 pagetables:1423 bounce:0 Jan 28 19:58:45 localhost kernel: [ 455.599687] free_cma:0 Jan 28 19:58:45 localhost kernel: [ 455.604585] Node 0 DMA free:7124kB min:412kB low:512kB high:616kB active_anon:8508kB inactive_anon:4kB active_file:0kB inactive_file:0kB unevictable:0kB isolated(anon):0kB isolated(file):0kB present:15992kB managed:15908kB mlocked:0kB dirty:0kB writeback:0kB mapped:0kB shmem:4kB slab_reclaimable:16kB slab_unreclaimable:16kB kernel_stack:0kB pagetables:12kB unstable:0kB bounce:0kB free_cma:0kB writeback_tmp:0kB pages_scanned:0 all_unreclaimable? yes Jan 28 19:58:45 localhost kernel: [ 455.610811] lowmem_reserve[]: 0 1679 1679 1679 Jan 28 19:58:45 localhost kernel: [ 455.611600] Node 0 DMA32 free:44592kB min:44640kB low:55800kB high:66960kB active_anon:1615456kB inactive_anon:224kB active_file:140kB inactive_file:276kB unevictable:0kB isolated(anon):0kB isolated(file):0kB present:1765368kB managed:1722912kB mlocked:0kB dirty:0kB writeback:0kB mapped:136kB shmem:276kB slab_reclaimable:6524kB slab_unreclaimable:7660kB kernel_stack:592kB pagetables:5680kB unstable:0kB bounce:0kB free_cma:0kB writeback_tmp:0kB pages_scanned:819 all_unreclaimable? yes Jan 28 19:58:45 localhost kernel: [ 455.618372] lowmem_reserve[]: 0 0 0 0 Jan 28 19:58:45 localhost kernel: [ 455.619041] Node 0 DMA: 5*4kB (UM) 6*8kB (UEM) 7*16kB (UEM) 1*32kB (M) 2*64kB (UE) 3*128kB (UEM) 1*256kB (E) 2*512kB (EM) 3*1024kB (UEM) 1*2048kB (R) 0*4096kB = 7124kB Jan 28 19:58:45 localhost kernel: [ 455.621861] Node 0 DMA32: 74*4kB (UEM) 125*8kB (UEM) 78*16kB (UEM) 26*32kB (UE) 12*64kB (UEM) 4*128kB (UE) 4*256kB (UE) 2*512kB (E) 11*1024kB (UE) 7*2048kB (UE) 3*4096kB (UR) = 44592kB Jan 28 19:58:45 localhost kernel: [ 455.625174] Node 0 hugepages_total=0 hugepages_free=0 hugepages_surp=0 hugepages_size=2048kB Jan 28 19:58:45 localhost kernel: [ 455.626394] 204 total pagecache pages Jan 28 19:58:45 localhost kernel: [ 455.626954] 0 pages in swap cache Jan 28 19:58:45 localhost kernel: [ 455.627455] Swap cache stats: add 0, delete 0, find 0/0 Jan 28 19:58:45 localhost kernel: [ 455.628242] Free swap = 0kB Jan 28 19:58:45 localhost kernel: [ 455.628686] Total swap = 0kB Jan 28 19:58:45 localhost kernel: [ 455.629147] 445340 pages RAM Jan 28 19:58:45 localhost kernel: [ 455.629577] 0 pages HighMem/MovableOnly Jan 28 19:58:45 localhost kernel: [ 455.630301] 10614 pages reserved Jan 28 19:58:45 localhost kernel: [ 455.630787] [ pid ] uid tgid total_vm rss nr_ptes swapents oom_score_adj name Jan 28 19:58:45 localhost kernel: [ 455.631937] [ 273] 0 273 4869 50 13 0 0 upstart-udev-br Jan 28 19:58:45 localhost kernel: [ 455.633290] [ 293] 0 293 12802 154 28 0 -1000 systemd-udevd Jan 28 19:58:45 localhost kernel: [ 455.634671] [ 321] 0 321 3819 54 12 0 0 upstart-file-br Jan 28 19:58:45 localhost kernel: [ 455.636070] [ 326] 102 326 9805 109 24 0 0 dbus-daemon Jan 28 19:58:45 localhost kernel: [ 455.637373] [ 334] 101 334 63960 94 26 0 0 rsyslogd Jan 28 19:58:45 localhost kernel: [ 455.638761] [ 343] 0 343 10863 102 26 0 0 systemd-logind Jan 28 19:58:45 localhost kernel: [ 455.640158] [ 546] 0 546 3815 60 13 0 0 upstart-socket- Jan 28 19:58:45 localhost kernel: [ 455.641534] [ 710] 0 710 2556 587 8 0 0 dhclient Jan 28 19:58:45 localhost kernel: [ 455.642834] [ 863] 0 863 3955 48 13 0 0 getty Jan 28 19:58:45 localhost kernel: [ 455.644139] [ 865] 0 865 3955 50 13 0 0 getty Jan 28 19:58:45 localhost kernel: [ 455.645325] [ 867] 0 867 3955 51 13 0 0 getty Jan 28 19:58:45 localhost kernel: [ 455.646621] [ 868] 0 868 3955 51 12 0 0 getty Jan 28 19:58:45 localhost kernel: [ 455.647963] [ 870] 0 870 3955 49 13 0 0 getty Jan 28 19:58:45 localhost kernel: [ 455.649234] [ 915] 0 915 5914 61 16 0 0 cron Jan 28 19:58:45 localhost kernel: [ 455.650439] [ 1015] 0 1015 10885 1524 25 0 0 manage_addresse Jan 28 19:58:45 localhost kernel: [ 455.651817] [ 1028] 0 1028 3955 49 13 0 0 getty Jan 28 19:58:45 localhost kernel: [ 455.653091] [ 1033] 0 1033 3197 48 12 0 0 getty Jan 28 19:58:45 localhost kernel: [ 455.654783] [ 1264] 0 1264 11031 1635 26 0 0 manage_accounts Jan 28 19:58:45 localhost kernel: [ 455.656657] [ 1268] 0 1268 15341 180 33 0 -1000 sshd Jan 28 19:58:45 localhost kernel: [ 455.657865] [ 1313] 104 1313 6804 154 17 0 0 ntpd Jan 28 19:58:45 localhost kernel: [ 455.659085] [ 1389] 0 1389 25889 255 55 0 0 sshd Jan 28 19:58:45 localhost kernel: [ 455.660440] [ 1407] 1020 1407 25889 255 52 0 0 sshd Jan 28 19:58:45 localhost kernel: [ 455.661595] [ 1408] 1020 1408 5711 581 17 0 0 bash Jan 28 19:58:45 localhost kernel: [ 455.662887] [ 1425] 0 1425 25889 256 53 0 0 sshd Jan 28 19:58:45 localhost kernel: [ 455.664075] [ 1443] 1020 1443 25889 257 52 0 0 sshd Jan 28 19:58:45 localhost kernel: [ 455.665330] [ 1444] 1020 1444 5711 581 16 0 0 bash Jan 28 19:58:45 localhost kernel: [ 455.666450] [ 1476] 1020 1476 1809 25 9 0 0 tail Jan 28 19:58:45 localhost kernel: [ 455.667682] [ 1532] 1020 1532 410347 398810 788 0 0 badsysprogram Jan 28 19:58:45 localhost kernel: [ 455.669006] Out of memory: Kill process 1532 (badsysprogram) score 919 or sacrifice child Jan 28 19:58:45 localhost kernel: [ 455.670291] Killed process 1532 (badsysprogram) total-vm:1641388kB, anon-rss:1595164kB, file-rss:76kB [ 0.170499] pnp 00:00: Plug and Play ACPI device, IDs PNP0b00 (active) [ 0.171591] pnp 00:01: Plug and Play ACPI device, IDs PNP0501 (active) [ 0.172574] pnp 00:02: Plug and Play ACPI device, IDs PNP0501 (active) cadvisor-0.25.0/utils/path.go000066400000000000000000000013551306035727200160440ustar00rootroot00000000000000// 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 utils import "os" func FileExists(file string) bool { if _, err := os.Stat(file); err != nil { return false } return true } cadvisor-0.25.0/utils/procfs/000077500000000000000000000000001306035727200160515ustar00rootroot00000000000000cadvisor-0.25.0/utils/procfs/doc.go000066400000000000000000000014171306035727200171500ustar00rootroot00000000000000// 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. // procfs contains several low level functions to read information from /proc // filesystem, and also provides some utility functions like JiffiesToDuration. package procfs cadvisor-0.25.0/utils/procfs/jiffy.go000066400000000000000000000016051306035727200175110ustar00rootroot00000000000000// 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 procfs /* #include */ import "C" import "time" var userHz uint64 func init() { userHzLong := C.sysconf(C._SC_CLK_TCK) userHz = uint64(userHzLong) } func JiffiesToDuration(jiffies uint64) time.Duration { d := jiffies * 1000000000 / userHz return time.Duration(d) } cadvisor-0.25.0/utils/sysfs/000077500000000000000000000000001306035727200157245ustar00rootroot00000000000000cadvisor-0.25.0/utils/sysfs/fakesysfs/000077500000000000000000000000001306035727200177225ustar00rootroot00000000000000cadvisor-0.25.0/utils/sysfs/fakesysfs/fake.go000066400000000000000000000053151306035727200211630ustar00rootroot00000000000000// 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 fakesysfs import ( "os" "time" "github.com/google/cadvisor/utils/sysfs" ) // If we extend sysfs to support more interfaces, it might be worth making this a mock instead of a fake. type FileInfo struct { EntryName string } func (self *FileInfo) Name() string { return self.EntryName } func (self *FileInfo) Size() int64 { return 1234567 } func (self *FileInfo) Mode() os.FileMode { return 0 } func (self *FileInfo) ModTime() time.Time { return time.Time{} } func (self *FileInfo) IsDir() bool { return true } func (self *FileInfo) Sys() interface{} { return nil } type FakeSysFs struct { info FileInfo cache sysfs.CacheInfo } func (self *FakeSysFs) GetBlockDevices() ([]os.FileInfo, error) { self.info.EntryName = "sda" return []os.FileInfo{&self.info}, nil } func (self *FakeSysFs) GetBlockDeviceSize(name string) (string, error) { return "1234567", nil } func (self *FakeSysFs) GetBlockDeviceScheduler(name string) (string, error) { return "noop deadline [cfq]", nil } func (self *FakeSysFs) GetBlockDeviceNumbers(name string) (string, error) { return "8:0\n", nil } func (self *FakeSysFs) GetNetworkDevices() ([]os.FileInfo, error) { return []os.FileInfo{&self.info}, nil } func (self *FakeSysFs) GetNetworkAddress(name string) (string, error) { return "42:01:02:03:04:f4\n", nil } func (self *FakeSysFs) GetNetworkMtu(name string) (string, error) { return "1024\n", nil } func (self *FakeSysFs) GetNetworkSpeed(name string) (string, error) { return "1000\n", nil } func (self *FakeSysFs) GetNetworkStatValue(name string, stat string) (uint64, error) { return 1024, nil } func (self *FakeSysFs) GetCaches(id int) ([]os.FileInfo, error) { self.info.EntryName = "index0" return []os.FileInfo{&self.info}, nil } func (self *FakeSysFs) GetCacheInfo(cpu int, cache string) (sysfs.CacheInfo, error) { return self.cache, nil } func (self *FakeSysFs) SetCacheInfo(cache sysfs.CacheInfo) { self.cache = cache } func (self *FakeSysFs) SetEntryName(name string) { self.info.EntryName = name } func (self *FakeSysFs) GetSystemUUID() (string, error) { return "1F862619-BA9F-4526-8F85-ECEAF0C97430", nil } cadvisor-0.25.0/utils/sysfs/sysfs.go000066400000000000000000000151571306035727200174330ustar00rootroot00000000000000// 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 sysfs import ( "fmt" "io/ioutil" "os" "path" "strconv" "strings" ) const ( blockDir = "/sys/block" cacheDir = "/sys/devices/system/cpu/cpu" netDir = "/sys/class/net" dmiDir = "/sys/class/dmi" ppcDevTree = "/proc/device-tree" s390xDevTree = "/etc" // s390/s390x changes ) type CacheInfo struct { // size in bytes Size uint64 // cache type - instruction, data, unified Type string // distance from cpus in a multi-level hierarchy Level int // number of cpus that can access this cache. Cpus int } // Abstracts the lowest level calls to sysfs. type SysFs interface { // Get directory information for available block devices. GetBlockDevices() ([]os.FileInfo, error) // Get Size of a given block device. GetBlockDeviceSize(string) (string, error) // Get scheduler type for the block device. GetBlockDeviceScheduler(string) (string, error) // Get device major:minor number string. GetBlockDeviceNumbers(string) (string, error) GetNetworkDevices() ([]os.FileInfo, error) GetNetworkAddress(string) (string, error) GetNetworkMtu(string) (string, error) GetNetworkSpeed(string) (string, error) GetNetworkStatValue(dev string, stat string) (uint64, error) // Get directory information for available caches accessible to given cpu. GetCaches(id int) ([]os.FileInfo, error) // Get information for a cache accessible from the given cpu. GetCacheInfo(cpu int, cache string) (CacheInfo, error) GetSystemUUID() (string, error) } type realSysFs struct{} func NewRealSysFs() (SysFs, error) { return &realSysFs{}, nil } func (self *realSysFs) GetBlockDevices() ([]os.FileInfo, error) { return ioutil.ReadDir(blockDir) } func (self *realSysFs) GetBlockDeviceNumbers(name string) (string, error) { dev, err := ioutil.ReadFile(path.Join(blockDir, name, "/dev")) if err != nil { return "", err } return string(dev), nil } func (self *realSysFs) GetBlockDeviceScheduler(name string) (string, error) { sched, err := ioutil.ReadFile(path.Join(blockDir, name, "/queue/scheduler")) if err != nil { return "", err } return string(sched), nil } func (self *realSysFs) GetBlockDeviceSize(name string) (string, error) { size, err := ioutil.ReadFile(path.Join(blockDir, name, "/size")) if err != nil { return "", err } return string(size), nil } func (self *realSysFs) GetNetworkDevices() ([]os.FileInfo, error) { files, err := ioutil.ReadDir(netDir) if err != nil { return nil, err } // Filter out non-directory & non-symlink files var dirs []os.FileInfo for _, f := range files { if f.Mode()|os.ModeSymlink != 0 { f, err = os.Stat(path.Join(netDir, f.Name())) if err != nil { continue } } if f.IsDir() { dirs = append(dirs, f) } } return dirs, nil } func (self *realSysFs) GetNetworkAddress(name string) (string, error) { address, err := ioutil.ReadFile(path.Join(netDir, name, "/address")) if err != nil { return "", err } return string(address), nil } func (self *realSysFs) GetNetworkMtu(name string) (string, error) { mtu, err := ioutil.ReadFile(path.Join(netDir, name, "/mtu")) if err != nil { return "", err } return string(mtu), nil } func (self *realSysFs) GetNetworkSpeed(name string) (string, error) { speed, err := ioutil.ReadFile(path.Join(netDir, name, "/speed")) if err != nil { return "", err } return string(speed), nil } func (self *realSysFs) GetNetworkStatValue(dev string, stat string) (uint64, error) { statPath := path.Join(netDir, dev, "/statistics", stat) out, err := ioutil.ReadFile(statPath) if err != nil { return 0, fmt.Errorf("failed to read stat from %q for device %q", statPath, dev) } var s uint64 n, err := fmt.Sscanf(string(out), "%d", &s) if err != nil || n != 1 { return 0, fmt.Errorf("could not parse value from %q for file %s", string(out), statPath) } return s, nil } func (self *realSysFs) GetCaches(id int) ([]os.FileInfo, error) { cpuPath := fmt.Sprintf("%s%d/cache", cacheDir, id) return ioutil.ReadDir(cpuPath) } func bitCount(i uint64) (count int) { for i != 0 { if i&1 == 1 { count++ } i >>= 1 } return } func getCpuCount(cache string) (count int, err error) { out, err := ioutil.ReadFile(path.Join(cache, "/shared_cpu_map")) if err != nil { return 0, err } masks := strings.Split(string(out), ",") for _, mask := range masks { // convert hex string to uint64 m, err := strconv.ParseUint(strings.TrimSpace(mask), 16, 64) if err != nil { return 0, fmt.Errorf("failed to parse cpu map %q: %v", string(out), err) } count += bitCount(m) } return } func (self *realSysFs) GetCacheInfo(id int, name string) (CacheInfo, error) { cachePath := fmt.Sprintf("%s%d/cache/%s", cacheDir, id, name) out, err := ioutil.ReadFile(path.Join(cachePath, "/size")) if err != nil { return CacheInfo{}, err } var size uint64 n, err := fmt.Sscanf(string(out), "%dK", &size) if err != nil || n != 1 { return CacheInfo{}, err } // convert to bytes size = size * 1024 out, err = ioutil.ReadFile(path.Join(cachePath, "/level")) if err != nil { return CacheInfo{}, err } var level int n, err = fmt.Sscanf(string(out), "%d", &level) if err != nil || n != 1 { return CacheInfo{}, err } out, err = ioutil.ReadFile(path.Join(cachePath, "/type")) if err != nil { return CacheInfo{}, err } cacheType := strings.TrimSpace(string(out)) cpuCount, err := getCpuCount(cachePath) if err != nil { return CacheInfo{}, err } return CacheInfo{ Size: size, Level: level, Type: cacheType, Cpus: cpuCount, }, nil } func (self *realSysFs) GetSystemUUID() (string, error) { if id, err := ioutil.ReadFile(path.Join(dmiDir, "id", "product_uuid")); err == nil { return strings.TrimSpace(string(id)), nil } else if id, err = ioutil.ReadFile(path.Join(ppcDevTree, "system-id")); err == nil { return strings.TrimSpace(string(id)), nil } else if id, err = ioutil.ReadFile(path.Join(ppcDevTree, "vm,uuid")); err == nil { return strings.TrimSpace(string(id)), nil } else if id, err = ioutil.ReadFile(path.Join(s390xDevTree, "machine-id")); err == nil { return strings.TrimSpace(string(id)), nil } else { return "", err } } cadvisor-0.25.0/utils/sysinfo/000077500000000000000000000000001306035727200162475ustar00rootroot00000000000000cadvisor-0.25.0/utils/sysinfo/sysinfo.go000066400000000000000000000130061306035727200202700ustar00rootroot00000000000000// 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 sysinfo import ( "fmt" "regexp" "strconv" "strings" info "github.com/google/cadvisor/info/v1" "github.com/google/cadvisor/utils/sysfs" ) var schedulerRegExp = regexp.MustCompile(`.*\[(.*)\].*`) // Get information about block devices present on the system. // Uses the passed in system interface to retrieve the low level OS information. func GetBlockDeviceInfo(sysfs sysfs.SysFs) (map[string]info.DiskInfo, error) { disks, err := sysfs.GetBlockDevices() if err != nil { return nil, err } diskMap := make(map[string]info.DiskInfo) for _, disk := range disks { name := disk.Name() // Ignore non-disk devices. // TODO(rjnagal): Maybe just match hd, sd, and dm prefixes. if strings.HasPrefix(name, "loop") || strings.HasPrefix(name, "ram") || strings.HasPrefix(name, "sr") { continue } disk_info := info.DiskInfo{ Name: name, } dev, err := sysfs.GetBlockDeviceNumbers(name) if err != nil { return nil, err } n, err := fmt.Sscanf(dev, "%d:%d", &disk_info.Major, &disk_info.Minor) if err != nil || n != 2 { return nil, fmt.Errorf("could not parse device numbers from %s for device %s", dev, name) } out, err := sysfs.GetBlockDeviceSize(name) if err != nil { return nil, err } // Remove trailing newline before conversion. size, err := strconv.ParseUint(strings.TrimSpace(out), 10, 64) if err != nil { return nil, err } // size is in 512 bytes blocks. disk_info.Size = size * 512 disk_info.Scheduler = "none" blkSched, err := sysfs.GetBlockDeviceScheduler(name) if err == nil { matches := schedulerRegExp.FindSubmatch([]byte(blkSched)) if len(matches) >= 2 { disk_info.Scheduler = string(matches[1]) } } device := fmt.Sprintf("%d:%d", disk_info.Major, disk_info.Minor) diskMap[device] = disk_info } return diskMap, nil } // Get information about network devices present on the system. func GetNetworkDevices(sysfs sysfs.SysFs) ([]info.NetInfo, error) { devs, err := sysfs.GetNetworkDevices() if err != nil { return nil, err } netDevices := []info.NetInfo{} for _, dev := range devs { name := dev.Name() // Ignore docker, loopback, and veth devices. ignoredDevices := []string{"lo", "veth", "docker"} ignored := false for _, prefix := range ignoredDevices { if strings.HasPrefix(name, prefix) { ignored = true break } } if ignored { continue } address, err := sysfs.GetNetworkAddress(name) if err != nil { return nil, err } mtuStr, err := sysfs.GetNetworkMtu(name) if err != nil { return nil, err } var mtu int64 n, err := fmt.Sscanf(mtuStr, "%d", &mtu) if err != nil || n != 1 { return nil, fmt.Errorf("could not parse mtu from %s for device %s", mtuStr, name) } netInfo := info.NetInfo{ Name: name, MacAddress: strings.TrimSpace(address), Mtu: mtu, } speed, err := sysfs.GetNetworkSpeed(name) // Some devices don't set speed. if err == nil { var s int64 n, err := fmt.Sscanf(speed, "%d", &s) if err != nil || n != 1 { return nil, fmt.Errorf("could not parse speed from %s for device %s", speed, name) } netInfo.Speed = s } netDevices = append(netDevices, netInfo) } return netDevices, nil } func GetCacheInfo(sysFs sysfs.SysFs, id int) ([]sysfs.CacheInfo, error) { caches, err := sysFs.GetCaches(id) if err != nil { return nil, err } info := []sysfs.CacheInfo{} for _, cache := range caches { if !strings.HasPrefix(cache.Name(), "index") { continue } cacheInfo, err := sysFs.GetCacheInfo(id, cache.Name()) if err != nil { return nil, err } info = append(info, cacheInfo) } return info, nil } func GetNetworkStats(name string) (info.InterfaceStats, error) { // TODO(rjnagal): Take syfs as an argument. sysFs, err := sysfs.NewRealSysFs() if err != nil { return info.InterfaceStats{}, err } return getNetworkStats(name, sysFs) } func getNetworkStats(name string, sysFs sysfs.SysFs) (info.InterfaceStats, error) { var stats info.InterfaceStats var err error stats.Name = name stats.RxBytes, err = sysFs.GetNetworkStatValue(name, "rx_bytes") if err != nil { return stats, err } stats.RxPackets, err = sysFs.GetNetworkStatValue(name, "rx_packets") if err != nil { return stats, err } stats.RxErrors, err = sysFs.GetNetworkStatValue(name, "rx_errors") if err != nil { return stats, err } stats.RxDropped, err = sysFs.GetNetworkStatValue(name, "rx_dropped") if err != nil { return stats, err } stats.TxBytes, err = sysFs.GetNetworkStatValue(name, "tx_bytes") if err != nil { return stats, err } stats.TxPackets, err = sysFs.GetNetworkStatValue(name, "tx_packets") if err != nil { return stats, err } stats.TxErrors, err = sysFs.GetNetworkStatValue(name, "tx_errors") if err != nil { return stats, err } stats.TxDropped, err = sysFs.GetNetworkStatValue(name, "tx_dropped") if err != nil { return stats, err } return stats, nil } func GetSystemUUID(sysFs sysfs.SysFs) (string, error) { return sysFs.GetSystemUUID() } cadvisor-0.25.0/utils/sysinfo/sysinfo_test.go000066400000000000000000000074371306035727200213420ustar00rootroot00000000000000// 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 sysinfo import ( "testing" info "github.com/google/cadvisor/info/v1" "github.com/google/cadvisor/utils/sysfs" "github.com/google/cadvisor/utils/sysfs/fakesysfs" ) func TestGetBlockDeviceInfo(t *testing.T) { fakeSys := fakesysfs.FakeSysFs{} disks, err := GetBlockDeviceInfo(&fakeSys) if err != nil { t.Errorf("expected call to GetBlockDeviceInfo() to succeed. Failed with %s", err) } if len(disks) != 1 { t.Errorf("expected to get one disk entry. Got %d", len(disks)) } key := "8:0" disk, ok := disks[key] if !ok { t.Fatalf("expected key 8:0 to exist in the disk map.") } if disk.Name != "sda" { t.Errorf("expected to get disk named sda. Got %q", disk.Name) } size := uint64(1234567 * 512) if disk.Size != size { t.Errorf("expected to get disk size of %d. Got %d", size, disk.Size) } if disk.Scheduler != "cfq" { t.Errorf("expected to get scheduler type of cfq. Got %q", disk.Scheduler) } } func TestGetNetworkDevices(t *testing.T) { fakeSys := fakesysfs.FakeSysFs{} fakeSys.SetEntryName("eth0") devs, err := GetNetworkDevices(&fakeSys) if err != nil { t.Errorf("expected call to GetNetworkDevices() to succeed. Failed with %s", err) } if len(devs) != 1 { t.Errorf("expected to get one network device. Got %d", len(devs)) } eth := devs[0] if eth.Name != "eth0" { t.Errorf("expected to find device with name eth0. Found name %q", eth.Name) } if eth.Mtu != 1024 { t.Errorf("expected mtu to be set to 1024. Found %d", eth.Mtu) } if eth.Speed != 1000 { t.Errorf("expected device speed to be set to 1000. Found %d", eth.Speed) } if eth.MacAddress != "42:01:02:03:04:f4" { t.Errorf("expected mac address to be '42:01:02:03:04:f4'. Found %q", eth.MacAddress) } } func TestIgnoredNetworkDevices(t *testing.T) { fakeSys := fakesysfs.FakeSysFs{} ignoredDevices := []string{"veth1234", "lo", "docker0"} for _, name := range ignoredDevices { fakeSys.SetEntryName(name) devs, err := GetNetworkDevices(&fakeSys) if err != nil { t.Errorf("expected call to GetNetworkDevices() to succeed. Failed with %s", err) } if len(devs) != 0 { t.Errorf("expected dev %s to be ignored, but got info %+v", name, devs) } } } func TestGetCacheInfo(t *testing.T) { fakeSys := &fakesysfs.FakeSysFs{} cacheInfo := sysfs.CacheInfo{ Size: 1024, Type: "Data", Level: 3, Cpus: 16, } fakeSys.SetCacheInfo(cacheInfo) caches, err := GetCacheInfo(fakeSys, 0) if err != nil { t.Errorf("expected call to GetCacheInfo() to succeed. Failed with %s", err) } if len(caches) != 1 { t.Errorf("expected to get one cache. Got %d", len(caches)) } if caches[0] != cacheInfo { t.Errorf("expected to find cacheinfo %+v. Got %+v", cacheInfo, caches[0]) } } func TestGetNetworkStats(t *testing.T) { expected_stats := info.InterfaceStats{ Name: "eth0", RxBytes: 1024, RxPackets: 1024, RxErrors: 1024, RxDropped: 1024, TxBytes: 1024, TxPackets: 1024, TxErrors: 1024, TxDropped: 1024, } fakeSys := &fakesysfs.FakeSysFs{} netStats, err := getNetworkStats("eth0", fakeSys) if err != nil { t.Errorf("call to getNetworkStats() failed with %s", err) } if expected_stats != netStats { t.Errorf("expected to get stats %+v, got %+v", expected_stats, netStats) } } cadvisor-0.25.0/utils/tail/000077500000000000000000000000001306035727200155065ustar00rootroot00000000000000cadvisor-0.25.0/utils/tail/tail.go000066400000000000000000000073471306035727200170010ustar00rootroot00000000000000// Copyright 2016 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Package tail implements "tail -F" functionality following rotated logs package tail import ( "bufio" "fmt" "io" "os" "path/filepath" "sync" "time" "github.com/golang/glog" "golang.org/x/exp/inotify" ) type Tail struct { reader *bufio.Reader readerErr error readerLock sync.RWMutex filename string file *os.File stop chan bool watcher *inotify.Watcher } const ( defaultRetryInterval = 100 * time.Millisecond maxRetryInterval = 30 * time.Second ) // NewTail starts opens the given file and watches it for deletion/rotation func NewTail(filename string) (*Tail, error) { t, err := newTail(filename) if err != nil { return nil, err } go t.watchLoop() return t, nil } // newTail creates a Tail object. func newTail(filename string) (*Tail, error) { t := &Tail{ filename: filename, } var err error t.stop = make(chan bool) t.watcher, err = inotify.NewWatcher() if err != nil { return nil, fmt.Errorf("inotify init failed on %s: %v", t.filename, err) } // Initialize readerErr as io.EOF, so that the reader can work properly // during initialization. t.readerErr = io.EOF return t, nil } // Read implements the io.Reader interface for Tail func (t *Tail) Read(p []byte) (int, error) { t.readerLock.RLock() defer t.readerLock.RUnlock() if t.readerErr != nil { return 0, t.readerErr } return t.reader.Read(p) } var _ io.ReadCloser = &Tail{} // Close stops watching and closes the file func (t *Tail) Close() error { close(t.stop) return nil } func (t *Tail) attemptOpen() error { t.readerLock.Lock() defer t.readerLock.Unlock() t.readerErr = nil attempt := 0 var lastErr error for interval := defaultRetryInterval; ; interval *= 2 { attempt++ glog.V(4).Infof("Opening %s (attempt %d)", t.filename, attempt) var err error t.file, err = os.Open(t.filename) if err == nil { // TODO: not interested in old events? // t.file.Seek(0, os.SEEK_END) t.reader = bufio.NewReader(t.file) return nil } lastErr = err glog.V(4).Infof("open log file %s error: %v", t.filename, err) if interval >= maxRetryInterval { break } select { case <-time.After(interval): case <-t.stop: t.readerErr = io.EOF return fmt.Errorf("watch was cancelled") } } err := fmt.Errorf("can't open log file %s: %v", t.filename, lastErr) t.readerErr = err return err } func (t *Tail) watchLoop() { for { err := t.watchFile() if err != nil { glog.Errorf("Tail failed on %s: %v", t.filename, err) break } } } func (t *Tail) watchFile() error { err := t.attemptOpen() if err != nil { return err } defer t.file.Close() watchDir := filepath.Dir(t.filename) err = t.watcher.AddWatch(watchDir, inotify.IN_MOVED_FROM|inotify.IN_DELETE) if err != nil { return fmt.Errorf("Failed to add watch to directory %s: %v", watchDir, err) } defer t.watcher.RemoveWatch(watchDir) for { select { case event := <-t.watcher.Event: eventPath := filepath.Clean(event.Name) // Directory events have an extra '/' if eventPath == t.filename { glog.V(4).Infof("Log file %s moved/deleted", t.filename) return nil } case <-t.stop: return fmt.Errorf("watch was cancelled") } } } cadvisor-0.25.0/utils/tail/tail_test.go000066400000000000000000000017671306035727200200400ustar00rootroot00000000000000// Copyright 2016 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package tail import ( "io" "testing" "github.com/stretchr/testify/assert" ) func TestReadNewTail(t *testing.T) { // Read should return (0, io.EOF) before first // attemptOpen. tail, err := newTail("test/nonexist/file") assert.NoError(t, err) buf := make([]byte, 0, 100) n, err := tail.Read(buf) assert.Equal(t, n, 0) assert.Equal(t, len(buf), 0) assert.EqualError(t, err, io.EOF.Error()) } cadvisor-0.25.0/utils/timed_store.go000066400000000000000000000116741306035727200174330ustar00rootroot00000000000000// 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 utils import ( "sort" "time" ) type timedStoreDataSlice []timedStoreData func (t timedStoreDataSlice) Less(i, j int) bool { return t[i].timestamp.Before(t[j].timestamp) } func (t timedStoreDataSlice) Len() int { return len(t) } func (t timedStoreDataSlice) Swap(i, j int) { t[i], t[j] = t[j], t[i] } // A time-based buffer for ContainerStats. // Holds information for a specific time period and/or a max number of items. type TimedStore struct { buffer timedStoreDataSlice age time.Duration maxItems int } type timedStoreData struct { timestamp time.Time data interface{} } // Returns a new thread-compatible TimedStore. // A maxItems value of -1 means no limit. func NewTimedStore(age time.Duration, maxItems int) *TimedStore { return &TimedStore{ buffer: make(timedStoreDataSlice, 0), age: age, maxItems: maxItems, } } // Adds an element to the start of the buffer (removing one from the end if necessary). func (self *TimedStore) Add(timestamp time.Time, item interface{}) { data := timedStoreData{ timestamp: timestamp, data: item, } // Common case: data is added in order. if len(self.buffer) == 0 || !timestamp.Before(self.buffer[len(self.buffer)-1].timestamp) { self.buffer = append(self.buffer, data) } else { // Data is out of order; insert it in the correct position. index := sort.Search(len(self.buffer), func(index int) bool { return self.buffer[index].timestamp.After(timestamp) }) self.buffer = append(self.buffer, timedStoreData{}) // Make room to shift the elements copy(self.buffer[index+1:], self.buffer[index:]) // Shift the elements over self.buffer[index] = data } // Remove any elements before eviction time. // TODO(rjnagal): This is assuming that the added entry has timestamp close to now. evictTime := timestamp.Add(-self.age) index := sort.Search(len(self.buffer), func(index int) bool { return self.buffer[index].timestamp.After(evictTime) }) if index < len(self.buffer) { self.buffer = self.buffer[index:] } // Remove any elements if over our max size. if self.maxItems >= 0 && len(self.buffer) > self.maxItems { startIndex := len(self.buffer) - self.maxItems self.buffer = self.buffer[startIndex:] } } // Returns up to maxResult elements in the specified time period (inclusive). // Results are from first to last. maxResults of -1 means no limit. func (self *TimedStore) InTimeRange(start, end time.Time, maxResults int) []interface{} { // No stats, return empty. if len(self.buffer) == 0 { return []interface{}{} } var startIndex int if start.IsZero() { // None specified, start at the beginning. startIndex = len(self.buffer) - 1 } else { // Start is the index before the elements smaller than it. We do this by // finding the first element smaller than start and taking the index // before that element startIndex = sort.Search(len(self.buffer), func(index int) bool { // buffer[index] < start return self.getData(index).timestamp.Before(start) }) - 1 // Check if start is after all the data we have. if startIndex < 0 { return []interface{}{} } } var endIndex int if end.IsZero() { // None specified, end with the latest stats. endIndex = 0 } else { // End is the first index smaller than or equal to it (so, not larger). endIndex = sort.Search(len(self.buffer), func(index int) bool { // buffer[index] <= t -> !(buffer[index] > t) return !self.getData(index).timestamp.After(end) }) // Check if end is before all the data we have. if endIndex == len(self.buffer) { return []interface{}{} } } // Trim to maxResults size. numResults := startIndex - endIndex + 1 if maxResults != -1 && numResults > maxResults { startIndex -= numResults - maxResults numResults = maxResults } // Return in sorted timestamp order so from the "back" to "front". result := make([]interface{}, numResults) for i := 0; i < numResults; i++ { result[i] = self.Get(startIndex - i) } return result } // Gets the element at the specified index. Note that elements are output in LIFO order. func (self *TimedStore) Get(index int) interface{} { return self.getData(index).data } // Gets the data at the specified index. Note that elements are output in LIFO order. func (self *TimedStore) getData(index int) timedStoreData { return self.buffer[len(self.buffer)-index-1] } func (self *TimedStore) Size() int { return len(self.buffer) } cadvisor-0.25.0/utils/timed_store_test.go000066400000000000000000000164521306035727200204710ustar00rootroot00000000000000// 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 utils import ( "testing" "time" "github.com/stretchr/testify/assert" ) func createTime(id int) time.Time { var zero time.Time return zero.Add(time.Duration(id+1) * time.Second) } func expectSize(t *testing.T, sb *TimedStore, expectedSize int) { if sb.Size() != expectedSize { t.Errorf("Expected size %v, got %v", expectedSize, sb.Size()) } } func expectAllElements(t *testing.T, sb *TimedStore, expected []int) { size := sb.Size() els := make([]interface{}, size) for i := 0; i < size; i++ { els[i] = sb.Get(size - i - 1) } expectElements(t, []interface{}(els), expected) } func expectElements(t *testing.T, actual []interface{}, expected []int) { if len(actual) != len(expected) { t.Errorf("Expected elements %v, got %v", expected, actual) return } for i, el := range actual { if el.(int) != expected[i] { t.Errorf("Expected elements %v, got %v", expected, actual) return } } } func TestAdd(t *testing.T) { sb := NewTimedStore(5*time.Second, 100) // Add 1. sb.Add(createTime(0), 0) expectSize(t, sb, 1) expectAllElements(t, sb, []int{0}) // Fill the buffer. for i := 1; i <= 5; i++ { expectSize(t, sb, i) sb.Add(createTime(i), i) } expectSize(t, sb, 5) expectAllElements(t, sb, []int{1, 2, 3, 4, 5}) // Add more than is available in the buffer sb.Add(createTime(6), 6) expectSize(t, sb, 5) expectAllElements(t, sb, []int{2, 3, 4, 5, 6}) // Replace all elements. for i := 7; i <= 10; i++ { sb.Add(createTime(i), i) } expectSize(t, sb, 5) expectAllElements(t, sb, []int{6, 7, 8, 9, 10}) } func TestGet(t *testing.T) { sb := NewTimedStore(5*time.Second, -1) sb.Add(createTime(1), 1) sb.Add(createTime(2), 2) sb.Add(createTime(3), 3) expectSize(t, sb, 3) assert := assert.New(t) assert.Equal(sb.Get(0).(int), 3) assert.Equal(sb.Get(1).(int), 2) assert.Equal(sb.Get(2).(int), 1) } func TestInTimeRange(t *testing.T) { sb := NewTimedStore(5*time.Second, -1) assert := assert.New(t) var empty time.Time // No elements. assert.Empty(sb.InTimeRange(createTime(0), createTime(5), 10)) assert.Empty(sb.InTimeRange(createTime(0), empty, 10)) assert.Empty(sb.InTimeRange(empty, createTime(5), 10)) assert.Empty(sb.InTimeRange(empty, empty, 10)) // One element. sb.Add(createTime(1), 1) expectSize(t, sb, 1) expectElements(t, sb.InTimeRange(createTime(0), createTime(5), 10), []int{1}) expectElements(t, sb.InTimeRange(createTime(1), createTime(5), 10), []int{1}) expectElements(t, sb.InTimeRange(createTime(0), createTime(1), 10), []int{1}) expectElements(t, sb.InTimeRange(createTime(1), createTime(1), 10), []int{1}) assert.Empty(sb.InTimeRange(createTime(2), createTime(5), 10)) // Two element. sb.Add(createTime(2), 2) expectSize(t, sb, 2) expectElements(t, sb.InTimeRange(createTime(0), createTime(5), 10), []int{1, 2}) expectElements(t, sb.InTimeRange(createTime(1), createTime(5), 10), []int{1, 2}) expectElements(t, sb.InTimeRange(createTime(0), createTime(2), 10), []int{1, 2}) expectElements(t, sb.InTimeRange(createTime(1), createTime(2), 10), []int{1, 2}) expectElements(t, sb.InTimeRange(createTime(1), createTime(1), 10), []int{1}) expectElements(t, sb.InTimeRange(createTime(2), createTime(2), 10), []int{2}) assert.Empty(sb.InTimeRange(createTime(3), createTime(5), 10)) // Many elements. sb.Add(createTime(3), 3) sb.Add(createTime(4), 4) expectSize(t, sb, 4) expectElements(t, sb.InTimeRange(createTime(0), createTime(5), 10), []int{1, 2, 3, 4}) expectElements(t, sb.InTimeRange(createTime(0), createTime(5), 10), []int{1, 2, 3, 4}) expectElements(t, sb.InTimeRange(createTime(1), createTime(5), 10), []int{1, 2, 3, 4}) expectElements(t, sb.InTimeRange(createTime(0), createTime(4), 10), []int{1, 2, 3, 4}) expectElements(t, sb.InTimeRange(createTime(1), createTime(4), 10), []int{1, 2, 3, 4}) expectElements(t, sb.InTimeRange(createTime(0), createTime(2), 10), []int{1, 2}) expectElements(t, sb.InTimeRange(createTime(1), createTime(2), 10), []int{1, 2}) expectElements(t, sb.InTimeRange(createTime(2), createTime(3), 10), []int{2, 3}) expectElements(t, sb.InTimeRange(createTime(3), createTime(4), 10), []int{3, 4}) expectElements(t, sb.InTimeRange(createTime(3), createTime(5), 10), []int{3, 4}) assert.Empty(sb.InTimeRange(createTime(5), createTime(5), 10)) // Start and end time does't ignore maxResults. expectElements(t, sb.InTimeRange(createTime(1), createTime(5), 1), []int{4}) // No start time. expectElements(t, sb.InTimeRange(empty, createTime(5), 10), []int{1, 2, 3, 4}) expectElements(t, sb.InTimeRange(empty, createTime(4), 10), []int{1, 2, 3, 4}) expectElements(t, sb.InTimeRange(empty, createTime(3), 10), []int{1, 2, 3}) expectElements(t, sb.InTimeRange(empty, createTime(2), 10), []int{1, 2}) expectElements(t, sb.InTimeRange(empty, createTime(1), 10), []int{1}) // No end time. expectElements(t, sb.InTimeRange(createTime(0), empty, 10), []int{1, 2, 3, 4}) expectElements(t, sb.InTimeRange(createTime(1), empty, 10), []int{1, 2, 3, 4}) expectElements(t, sb.InTimeRange(createTime(2), empty, 10), []int{2, 3, 4}) expectElements(t, sb.InTimeRange(createTime(3), empty, 10), []int{3, 4}) expectElements(t, sb.InTimeRange(createTime(4), empty, 10), []int{4}) // No start or end time. expectElements(t, sb.InTimeRange(empty, empty, 10), []int{1, 2, 3, 4}) // Start after data. assert.Empty(sb.InTimeRange(createTime(5), createTime(5), 10)) assert.Empty(sb.InTimeRange(createTime(5), empty, 10)) // End before data. assert.Empty(sb.InTimeRange(createTime(0), createTime(0), 10)) assert.Empty(sb.InTimeRange(empty, createTime(0), 10)) } func TestInTimeRangeWithLimit(t *testing.T) { sb := NewTimedStore(5*time.Second, -1) sb.Add(createTime(1), 1) sb.Add(createTime(2), 2) sb.Add(createTime(3), 3) sb.Add(createTime(4), 4) expectSize(t, sb, 4) var empty time.Time // Limit cuts off from latest timestamp. expectElements(t, sb.InTimeRange(empty, empty, 4), []int{1, 2, 3, 4}) expectElements(t, sb.InTimeRange(empty, empty, 3), []int{2, 3, 4}) expectElements(t, sb.InTimeRange(empty, empty, 2), []int{3, 4}) expectElements(t, sb.InTimeRange(empty, empty, 1), []int{4}) assert.Empty(t, sb.InTimeRange(empty, empty, 0)) } func TestLimitedSize(t *testing.T) { sb := NewTimedStore(time.Hour, 5) // Add 1. sb.Add(createTime(0), 0) expectSize(t, sb, 1) expectAllElements(t, sb, []int{0}) // Fill the buffer. for i := 1; i <= 5; i++ { expectSize(t, sb, i) sb.Add(createTime(i), i) } expectSize(t, sb, 5) expectAllElements(t, sb, []int{1, 2, 3, 4, 5}) // Add more than is available in the buffer sb.Add(createTime(6), 6) expectSize(t, sb, 5) expectAllElements(t, sb, []int{2, 3, 4, 5, 6}) // Replace all elements. for i := 7; i <= 10; i++ { sb.Add(createTime(i), i) } expectSize(t, sb, 5) expectAllElements(t, sb, []int{6, 7, 8, 9, 10}) } cadvisor-0.25.0/utils/utils.go000066400000000000000000000015661306035727200162540ustar00rootroot00000000000000// Copyright 2015 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 utils import "fmt" // Returns a mask of all cores on the machine if the passed-in mask is empty. func FixCpuMask(mask string, cores int) string { if mask == "" { if cores > 1 { mask = fmt.Sprintf("0-%d", cores-1) } else { mask = "0" } } return mask } cadvisor-0.25.0/validate/000077500000000000000000000000001306035727200152065ustar00rootroot00000000000000cadvisor-0.25.0/validate/validate.go000066400000000000000000000223731306035727200173350ustar00rootroot00000000000000// 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 /validate content. // Validates cadvisor dependencies - kernel, os, docker setup. package validate import ( "fmt" "io/ioutil" "log" "net/http" "path" "strings" "github.com/google/cadvisor/container/docker" "github.com/google/cadvisor/manager" "github.com/google/cadvisor/utils" "github.com/opencontainers/runc/libcontainer/cgroups" ) const ( ValidatePage = "/validate/" Supported = "[Supported, but not recommended]" Unsupported = "[Unsupported]" Recommended = "[Supported and recommended]" Unknown = "[Unknown]" VersionFormat = "%d.%d%s" OutputFormat = "%s: %s\n\t%s\n\n" ) func getMajorMinor(version string) (int, int, error) { var major, minor int var ign string n, err := fmt.Sscanf(version, VersionFormat, &major, &minor, &ign) if n != 3 || err != nil { log.Printf("Failed to parse version for %s", version) return -1, -1, err } return major, minor, nil } func validateKernelVersion(version string) (string, string) { desc := fmt.Sprintf("Kernel version is %s. Versions >= 2.6 are supported. 3.0+ are recommended.\n", version) major, minor, err := getMajorMinor(version) if err != nil { desc = fmt.Sprintf("Could not parse kernel version. %s", desc) return Unknown, desc } if major < 2 { return Unsupported, desc } if major == 2 && minor < 6 { return Unsupported, desc } if major >= 3 { return Recommended, desc } return Supported, desc } func validateDockerVersion(version string) (string, string) { desc := fmt.Sprintf("Docker version is %s. Versions >= 1.0 are supported. 1.2+ are recommended.\n", version) major, minor, err := getMajorMinor(version) if err != nil { desc = fmt.Sprintf("Could not parse docker version. %s\n\t", desc) return Unknown, desc } if major < 1 { return Unsupported, desc } if major == 1 && minor < 2 { return Supported, desc } return Recommended, desc } func getEnabledCgroups() (map[string]int, error) { out, err := ioutil.ReadFile("/proc/cgroups") if err != nil { return nil, err } cgroups := make(map[string]int) for i, line := range strings.Split(string(out), "\n") { var cgroup string var ign, enabled int if i == 0 || line == "" { continue } n, err := fmt.Sscanf(line, "%s %d %d %d", &cgroup, &ign, &ign, &enabled) if n != 4 || err != nil { if err == nil { err = fmt.Errorf("failed to parse /proc/cgroup entry %s", line) } return nil, err } cgroups[cgroup] = enabled } return cgroups, nil } func areCgroupsPresent(available map[string]int, desired []string) (bool, string) { for _, cgroup := range desired { enabled, ok := available[cgroup] if !ok { reason := fmt.Sprintf("Missing cgroup %s. Available cgroups: %v\n", cgroup, available) return false, reason } if enabled != 1 { reason := fmt.Sprintf("Cgroup %s not enabled. Available cgroups: %v\n", cgroup, available) return false, reason } } return true, "" } func validateMemoryAccounting(available_cgroups map[string]int) string { ok, _ := areCgroupsPresent(available_cgroups, []string{"memory"}) if !ok { return "\tHierarchical memory accounting status unknown: memory cgroup not enabled.\n" } mnt, err := cgroups.FindCgroupMountpoint("memory") if err != nil { return "\tHierarchical memory accounting status unknown: memory cgroup not mounted.\n" } hier, err := ioutil.ReadFile(path.Join(mnt, "memory.use_hierarchy")) if err != nil { return "\tHierarchical memory accounting status unknown: hierarchy interface unavailable.\n" } var enabled int n, err := fmt.Sscanf(string(hier), "%d", &enabled) if err != nil || n != 1 { return "\tHierarchical memory accounting status unknown: hierarchy interface unreadable.\n" } if enabled == 1 { return "\tHierarchical memory accounting enabled. Reported memory usage includes memory used by child containers.\n" } return "\tHierarchical memory accounting disabled. Memory usage does not include usage from child containers.\n" } func validateCgroups() (string, string) { required_cgroups := []string{"cpu", "cpuacct"} recommended_cgroups := []string{"memory", "blkio", "cpuset", "devices", "freezer"} available_cgroups, err := getEnabledCgroups() desc := fmt.Sprintf("\tFollowing cgroups are required: %v\n\tFollowing other cgroups are recommended: %v\n", required_cgroups, recommended_cgroups) if err != nil { desc = fmt.Sprintf("Could not parse /proc/cgroups.\n%s", desc) return Unknown, desc } ok, out := areCgroupsPresent(available_cgroups, required_cgroups) if !ok { out += desc return Unsupported, out } ok, out = areCgroupsPresent(available_cgroups, recommended_cgroups) if !ok { // supported, but not recommended. out += desc return Supported, out } out = fmt.Sprintf("Available cgroups: %v\n", available_cgroups) out += desc out += validateMemoryAccounting(available_cgroups) return Recommended, out } func validateDockerInfo() (string, string) { info, err := docker.ValidateInfo() if err != nil { return Unsupported, fmt.Sprintf("Docker setup is invalid: %v", err) } desc := fmt.Sprintf("Docker exec driver is %s. Storage driver is %s.\n", info.ExecutionDriver, info.Driver) return Recommended, desc } func validateCgroupMounts() (string, string) { const recommendedMount = "/sys/fs/cgroup" desc := fmt.Sprintf("\tAny cgroup mount point that is detectible and accessible is supported. %s is recommended as a standard location.\n", recommendedMount) mnt, err := cgroups.FindCgroupMountpoint("cpu") if err != nil { out := "Could not locate cgroup mount point.\n" out += desc return Unknown, out } mnt = path.Dir(mnt) if !utils.FileExists(mnt) { out := fmt.Sprintf("Cgroup mount directory %s inaccessible.\n", mnt) out += desc return Unsupported, out } mounts, err := ioutil.ReadDir(mnt) if err != nil { out := fmt.Sprintf("Could not read cgroup mount directory %s.\n", mnt) out += desc return Unsupported, out } mountNames := "\tCgroup mount directories: " for _, mount := range mounts { mountNames += mount.Name() + " " } mountNames += "\n" out := fmt.Sprintf("Cgroups are mounted at %s.\n", mnt) out += mountNames out += desc info, err := ioutil.ReadFile("/proc/mounts") if err != nil { out := fmt.Sprintf("Could not read /proc/mounts.\n") out += desc return Unsupported, out } out += "\tCgroup mounts:\n" for _, line := range strings.Split(string(info), "\n") { if strings.Contains(line, " cgroup ") { out += "\t" + line + "\n" } } if mnt == recommendedMount { return Recommended, out } return Supported, out } func validateIoScheduler(containerManager manager.Manager) (string, string) { var desc string mi, err := containerManager.GetMachineInfo() if err != nil { return Unknown, "Machine info not available\n\t" } cfq := false for _, disk := range mi.DiskMap { desc += fmt.Sprintf("\t Disk %q Scheduler type %q.\n", disk.Name, disk.Scheduler) if disk.Scheduler == "cfq" { cfq = true } } // Since we get lot of random block devices, report recommended if // at least one of them is on cfq. Report Supported otherwise. if cfq { desc = "At least one device supports 'cfq' I/O scheduler. Some disk stats can be reported.\n" + desc return Recommended, desc } desc = "None of the devices support 'cfq' I/O scheduler. No disk stats can be reported.\n" + desc return Supported, desc } func HandleRequest(w http.ResponseWriter, containerManager manager.Manager) error { // Get cAdvisor version Info. versionInfo, err := containerManager.GetVersionInfo() if err != nil { return err } out := fmt.Sprintf("cAdvisor version: %s\n\n", versionInfo.CadvisorVersion) // No OS is preferred or unsupported as of now. out += fmt.Sprintf("OS version: %s\n\n", versionInfo.ContainerOsVersion) kernelValidation, desc := validateKernelVersion(versionInfo.KernelVersion) out += fmt.Sprintf(OutputFormat, "Kernel version", kernelValidation, desc) cgroupValidation, desc := validateCgroups() out += fmt.Sprintf(OutputFormat, "Cgroup setup", cgroupValidation, desc) mountsValidation, desc := validateCgroupMounts() out += fmt.Sprintf(OutputFormat, "Cgroup mount setup", mountsValidation, desc) dockerValidation, desc := validateDockerVersion(versionInfo.DockerVersion) out += fmt.Sprintf(OutputFormat, "Docker version", dockerValidation, desc) dockerInfoValidation, desc := validateDockerInfo() out += fmt.Sprintf(OutputFormat, "Docker driver setup", dockerInfoValidation, desc) ioSchedulerValidation, desc := validateIoScheduler(containerManager) out += fmt.Sprintf(OutputFormat, "Block device setup", ioSchedulerValidation, desc) // Output debug info. debugInfo := containerManager.DebugInfo() for category, lines := range debugInfo { out += fmt.Sprintf(OutputFormat, category, "", strings.Join(lines, "\n\t")) } _, err = w.Write([]byte(out)) return err } cadvisor-0.25.0/validate/validate_test.go000066400000000000000000000076721306035727200204010ustar00rootroot00000000000000// Copyright 2015 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 validate import ( "fmt" "strings" "testing" ) var ( standardDesc = "Versions >= %s are supported. %s+ are recommended" dockerStandardDesc = fmt.Sprintf(standardDesc, "1.0", "1.2") kernelStandardDesc = fmt.Sprintf(standardDesc, "2.6", "3.0") dockerErrorDesc = "Could not parse docker version" kernelErrorDesc = "Could not parse kernel version" ) func TestGetMajorMinor(t *testing.T) { cases := []struct { version string major int minor int err error }{ {"0.1beta", 0, 1, nil}, {"0.1.2", 0, 1, nil}, {"-1.-1beta", -1, -1, nil}, {"0.1", -1, -1, fmt.Errorf("have error")}, {"0", -1, -1, fmt.Errorf("have error")}, {"beta", -1, -1, fmt.Errorf("have error")}, } for i, c := range cases { ma, mi, e := getMajorMinor(c.version) if (e != nil) != (c.err != nil) { t.Errorf("[%d] Unexpected err, should %v, but got %v", i, c.err, e) } if ma != c.major { t.Errorf("[%d] Unexpected major, should %v, but got %v", i, c.major, ma) } if mi != c.minor { t.Errorf("[%d] Unexpected minor, should %v, but got %v", i, c.minor, mi) } } } func TestValidateKernelVersion(t *testing.T) { cases := []struct { version string result string desc string }{ {"2.6.3", Supported, kernelStandardDesc}, {"3.6.3", Recommended, kernelStandardDesc}, {"1.0beta", Unsupported, kernelStandardDesc}, {"0.1beta", Unsupported, kernelStandardDesc}, {"0.1", Unknown, kernelErrorDesc}, {"3.1", Unknown, kernelErrorDesc}, } for i, c := range cases { res, desc := validateKernelVersion(c.version) if res != c.result { t.Errorf("[%d] Unexpected result, should %v, but got %v", i, c.result, res) } if !strings.Contains(desc, c.desc) { t.Errorf("[%d] Unexpected description, should %v, but got %v", i, c.desc, desc) } } } func TestValidateDockerVersion(t *testing.T) { cases := []struct { version string result string desc string }{ {"1.1.3", Supported, dockerStandardDesc}, {"1.6.3", Recommended, dockerStandardDesc}, {"1.0beta", Supported, dockerStandardDesc}, {"0.1beta", Unsupported, dockerStandardDesc}, {"0.1", Unknown, dockerErrorDesc}, {"1.6", Unknown, dockerErrorDesc}, } for i, c := range cases { res, desc := validateDockerVersion(c.version) if res != c.result { t.Errorf("[%d] Unexpected result, should %v, but got %v", i, c.result, res) } if !strings.Contains(desc, c.desc) { t.Errorf("[%d] Unexpected description, should %v, but got %v", i, c.desc, desc) } } } func TestAreCgroupsPresent(t *testing.T) { cases := []struct { available map[string]int desired []string result bool reason string }{ {map[string]int{"memory": 1}, []string{"memory"}, true, ""}, {map[string]int{"memory": 2}, []string{"memory"}, false, "memory not enabled. Available cgroups"}, {map[string]int{"memory": 0}, []string{"memory"}, false, "memory not enabled. Available cgroups"}, {map[string]int{"memory": 1}, []string{"blkio"}, false, "Missing cgroup blkio. Available cgroups"}, } for i, c := range cases { result, reason := areCgroupsPresent(c.available, c.desired) if result != c.result { t.Errorf("[%d] Unexpected result, should %v, but got %v", i, c.result, result) } if (c.reason == "" && reason != "") || (c.reason != "" && !strings.Contains(reason, c.reason)) { t.Errorf("[%d] Unexpected result, should %v, but got %v", i, c.reason, reason) } } } cadvisor-0.25.0/vendor/000077500000000000000000000000001306035727200147125ustar00rootroot00000000000000cadvisor-0.25.0/vendor/bitbucket.org/000077500000000000000000000000001306035727200174545ustar00rootroot00000000000000cadvisor-0.25.0/vendor/bitbucket.org/ww/000077500000000000000000000000001306035727200201115ustar00rootroot00000000000000cadvisor-0.25.0/vendor/bitbucket.org/ww/goautoneg/000077500000000000000000000000001306035727200221015ustar00rootroot00000000000000cadvisor-0.25.0/vendor/bitbucket.org/ww/goautoneg/Makefile000066400000000000000000000002741306035727200235440ustar00rootroot00000000000000include $(GOROOT)/src/Make.inc TARG=bitbucket.org/ww/goautoneg GOFILES=autoneg.go include $(GOROOT)/src/Make.pkg format: gofmt -w *.go docs: gomake clean godoc ${TARG} > README.txt cadvisor-0.25.0/vendor/bitbucket.org/ww/goautoneg/README.txt000066400000000000000000000043341306035727200236030ustar00rootroot00000000000000PACKAGE package goautoneg import "bitbucket.org/ww/goautoneg" HTTP Content-Type Autonegotiation. The functions in this package implement the behaviour specified in http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html Copyright (c) 2011, Open Knowledge Foundation Ltd. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. Neither the name of the Open Knowledge Foundation Ltd. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. FUNCTIONS func Negotiate(header string, alternatives []string) (content_type string) Negotiate the most appropriate content_type given the accept header and a list of alternatives. func ParseAccept(header string) (accept []Accept) Parse an Accept Header string returning a sorted list of clauses TYPES type Accept struct { Type, SubType string Q float32 Params map[string]string } Structure to represent a clause in an HTTP Accept Header SUBDIRECTORIES .hg cadvisor-0.25.0/vendor/bitbucket.org/ww/goautoneg/autoneg.go000066400000000000000000000103151306035727200240720ustar00rootroot00000000000000/* HTTP Content-Type Autonegotiation. The functions in this package implement the behaviour specified in http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html Copyright (c) 2011, Open Knowledge Foundation Ltd. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. Neither the name of the Open Knowledge Foundation Ltd. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ package goautoneg import ( "sort" "strconv" "strings" ) // Structure to represent a clause in an HTTP Accept Header type Accept struct { Type, SubType string Q float64 Params map[string]string } // For internal use, so that we can use the sort interface type accept_slice []Accept func (accept accept_slice) Len() int { slice := []Accept(accept) return len(slice) } func (accept accept_slice) Less(i, j int) bool { slice := []Accept(accept) ai, aj := slice[i], slice[j] if ai.Q > aj.Q { return true } if ai.Type != "*" && aj.Type == "*" { return true } if ai.SubType != "*" && aj.SubType == "*" { return true } return false } func (accept accept_slice) Swap(i, j int) { slice := []Accept(accept) slice[i], slice[j] = slice[j], slice[i] } // Parse an Accept Header string returning a sorted list // of clauses func ParseAccept(header string) (accept []Accept) { parts := strings.Split(header, ",") accept = make([]Accept, 0, len(parts)) for _, part := range parts { part := strings.Trim(part, " ") a := Accept{} a.Params = make(map[string]string) a.Q = 1.0 mrp := strings.Split(part, ";") media_range := mrp[0] sp := strings.Split(media_range, "/") a.Type = strings.Trim(sp[0], " ") switch { case len(sp) == 1 && a.Type == "*": a.SubType = "*" case len(sp) == 2: a.SubType = strings.Trim(sp[1], " ") default: continue } if len(mrp) == 1 { accept = append(accept, a) continue } for _, param := range mrp[1:] { sp := strings.SplitN(param, "=", 2) if len(sp) != 2 { continue } token := strings.Trim(sp[0], " ") if token == "q" { a.Q, _ = strconv.ParseFloat(sp[1], 32) } else { a.Params[token] = strings.Trim(sp[1], " ") } } accept = append(accept, a) } slice := accept_slice(accept) sort.Sort(slice) return } // Negotiate the most appropriate content_type given the accept header // and a list of alternatives. func Negotiate(header string, alternatives []string) (content_type string) { asp := make([][]string, 0, len(alternatives)) for _, ctype := range alternatives { asp = append(asp, strings.SplitN(ctype, "/", 2)) } for _, clause := range ParseAccept(header) { for i, ctsp := range asp { if clause.Type == ctsp[0] && clause.SubType == ctsp[1] { content_type = alternatives[i] return } if clause.Type == ctsp[0] && clause.SubType == "*" { content_type = alternatives[i] return } if clause.Type == "*" && clause.SubType == "*" { content_type = alternatives[i] return } } } return } cadvisor-0.25.0/vendor/cloud.google.com/000077500000000000000000000000001306035727200200505ustar00rootroot00000000000000cadvisor-0.25.0/vendor/github.com/000077500000000000000000000000001306035727200167515ustar00rootroot00000000000000cadvisor-0.25.0/vendor/github.com/Microsoft/000077500000000000000000000000001306035727200207165ustar00rootroot00000000000000cadvisor-0.25.0/vendor/github.com/SeanDolphin/000077500000000000000000000000001306035727200211555ustar00rootroot00000000000000cadvisor-0.25.0/vendor/github.com/Shopify/000077500000000000000000000000001306035727200203725ustar00rootroot00000000000000cadvisor-0.25.0/vendor/github.com/Sirupsen/000077500000000000000000000000001306035727200205615ustar00rootroot00000000000000cadvisor-0.25.0/vendor/github.com/abbot/000077500000000000000000000000001306035727200200405ustar00rootroot00000000000000cadvisor-0.25.0/vendor/github.com/aws/000077500000000000000000000000001306035727200175435ustar00rootroot00000000000000cadvisor-0.25.0/vendor/github.com/beorn7/000077500000000000000000000000001306035727200201455ustar00rootroot00000000000000cadvisor-0.25.0/vendor/github.com/blang/000077500000000000000000000000001306035727200200345ustar00rootroot00000000000000cadvisor-0.25.0/vendor/github.com/coreos/000077500000000000000000000000001306035727200202435ustar00rootroot00000000000000cadvisor-0.25.0/vendor/github.com/coreos/rkt/000077500000000000000000000000001306035727200210435ustar00rootroot00000000000000cadvisor-0.25.0/vendor/github.com/coreos/rkt/LICENSE000066400000000000000000000260741306035727200220610ustar00rootroot00000000000000Apache 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 APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "{}" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright {yyyy} {name of copyright owner} 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. cadvisor-0.25.0/vendor/github.com/coreos/rkt/api/000077500000000000000000000000001306035727200216145ustar00rootroot00000000000000cadvisor-0.25.0/vendor/github.com/coreos/rkt/api/v1alpha/000077500000000000000000000000001306035727200231505ustar00rootroot00000000000000cadvisor-0.25.0/vendor/github.com/coreos/rkt/api/v1alpha/README.md000066400000000000000000000012051306035727200244250ustar00rootroot00000000000000# WARNING The API defined here is proposed, experimental, and (for now) subject to change at any time. If you think you want to use it, or for any other queries, contact or file an [issue](https://github.com/coreos/rkt/issues/new) For more information, see: - #1208 - #1359 - #1468 - [API Service Subcommand](../../Documentation/subcommands/api-service.md) ## Protobuf The rkt gRPC API uses Protocol Buffers for its services. In order to rebuild the generated code make sure you have protobuf 3.0.0 installed (https://github.com/google/protobuf) and execute from the top-level directory: ``` $ make protobuf ``` cadvisor-0.25.0/vendor/github.com/coreos/rkt/api/v1alpha/api.pb.go000066400000000000000000001501001306035727200246450ustar00rootroot00000000000000// Code generated by protoc-gen-go. // source: api.proto // DO NOT EDIT! /* Package v1alpha is a generated protocol buffer package. It is generated from these files: api.proto It has these top-level messages: ImageFormat Image Network App Pod KeyValue PodFilter ImageFilter GlobalFlags Info Event EventFilter GetInfoRequest GetInfoResponse ListPodsRequest ListPodsResponse InspectPodRequest InspectPodResponse ListImagesRequest ListImagesResponse InspectImageRequest InspectImageResponse ListenEventsRequest ListenEventsResponse GetLogsRequest GetLogsResponse */ package v1alpha import proto "github.com/golang/protobuf/proto" import fmt "fmt" import math "math" import ( context "golang.org/x/net/context" grpc "google.golang.org/grpc" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. const _ = proto.ProtoPackageIsVersion1 // ImageType defines the supported image type. type ImageType int32 const ( ImageType_IMAGE_TYPE_UNDEFINED ImageType = 0 ImageType_IMAGE_TYPE_APPC ImageType = 1 ImageType_IMAGE_TYPE_DOCKER ImageType = 2 ImageType_IMAGE_TYPE_OCI ImageType = 3 ) var ImageType_name = map[int32]string{ 0: "IMAGE_TYPE_UNDEFINED", 1: "IMAGE_TYPE_APPC", 2: "IMAGE_TYPE_DOCKER", 3: "IMAGE_TYPE_OCI", } var ImageType_value = map[string]int32{ "IMAGE_TYPE_UNDEFINED": 0, "IMAGE_TYPE_APPC": 1, "IMAGE_TYPE_DOCKER": 2, "IMAGE_TYPE_OCI": 3, } func (x ImageType) String() string { return proto.EnumName(ImageType_name, int32(x)) } func (ImageType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } // AppState defines the possible states of the app. type AppState int32 const ( AppState_APP_STATE_UNDEFINED AppState = 0 AppState_APP_STATE_RUNNING AppState = 1 AppState_APP_STATE_EXITED AppState = 2 ) var AppState_name = map[int32]string{ 0: "APP_STATE_UNDEFINED", 1: "APP_STATE_RUNNING", 2: "APP_STATE_EXITED", } var AppState_value = map[string]int32{ "APP_STATE_UNDEFINED": 0, "APP_STATE_RUNNING": 1, "APP_STATE_EXITED": 2, } func (x AppState) String() string { return proto.EnumName(AppState_name, int32(x)) } func (AppState) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1} } // PodState defines the possible states of the pod. // See https://github.com/coreos/rkt/blob/master/Documentation/devel/pod-lifecycle.md for a detailed // explanation of each state. type PodState int32 const ( PodState_POD_STATE_UNDEFINED PodState = 0 // States before the pod is running. PodState_POD_STATE_EMBRYO PodState = 1 PodState_POD_STATE_PREPARING PodState = 2 PodState_POD_STATE_PREPARED PodState = 3 // State that indicates the pod is running. PodState_POD_STATE_RUNNING PodState = 4 // States that indicates the pod is exited, and will never run. PodState_POD_STATE_ABORTED_PREPARE PodState = 5 PodState_POD_STATE_EXITED PodState = 6 PodState_POD_STATE_DELETING PodState = 7 PodState_POD_STATE_GARBAGE PodState = 8 ) var PodState_name = map[int32]string{ 0: "POD_STATE_UNDEFINED", 1: "POD_STATE_EMBRYO", 2: "POD_STATE_PREPARING", 3: "POD_STATE_PREPARED", 4: "POD_STATE_RUNNING", 5: "POD_STATE_ABORTED_PREPARE", 6: "POD_STATE_EXITED", 7: "POD_STATE_DELETING", 8: "POD_STATE_GARBAGE", } var PodState_value = map[string]int32{ "POD_STATE_UNDEFINED": 0, "POD_STATE_EMBRYO": 1, "POD_STATE_PREPARING": 2, "POD_STATE_PREPARED": 3, "POD_STATE_RUNNING": 4, "POD_STATE_ABORTED_PREPARE": 5, "POD_STATE_EXITED": 6, "POD_STATE_DELETING": 7, "POD_STATE_GARBAGE": 8, } func (x PodState) String() string { return proto.EnumName(PodState_name, int32(x)) } func (PodState) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{2} } // EventType defines the type of the events that will be received via ListenEvents(). type EventType int32 const ( EventType_EVENT_TYPE_UNDEFINED EventType = 0 // Pod events. EventType_EVENT_TYPE_POD_PREPARED EventType = 1 EventType_EVENT_TYPE_POD_PREPARE_ABORTED EventType = 2 EventType_EVENT_TYPE_POD_STARTED EventType = 3 EventType_EVENT_TYPE_POD_EXITED EventType = 4 EventType_EVENT_TYPE_POD_GARBAGE_COLLECTED EventType = 5 // App events. EventType_EVENT_TYPE_APP_STARTED EventType = 6 EventType_EVENT_TYPE_APP_EXITED EventType = 7 // Image events. EventType_EVENT_TYPE_IMAGE_IMPORTED EventType = 8 EventType_EVENT_TYPE_IMAGE_REMOVED EventType = 9 ) var EventType_name = map[int32]string{ 0: "EVENT_TYPE_UNDEFINED", 1: "EVENT_TYPE_POD_PREPARED", 2: "EVENT_TYPE_POD_PREPARE_ABORTED", 3: "EVENT_TYPE_POD_STARTED", 4: "EVENT_TYPE_POD_EXITED", 5: "EVENT_TYPE_POD_GARBAGE_COLLECTED", 6: "EVENT_TYPE_APP_STARTED", 7: "EVENT_TYPE_APP_EXITED", 8: "EVENT_TYPE_IMAGE_IMPORTED", 9: "EVENT_TYPE_IMAGE_REMOVED", } var EventType_value = map[string]int32{ "EVENT_TYPE_UNDEFINED": 0, "EVENT_TYPE_POD_PREPARED": 1, "EVENT_TYPE_POD_PREPARE_ABORTED": 2, "EVENT_TYPE_POD_STARTED": 3, "EVENT_TYPE_POD_EXITED": 4, "EVENT_TYPE_POD_GARBAGE_COLLECTED": 5, "EVENT_TYPE_APP_STARTED": 6, "EVENT_TYPE_APP_EXITED": 7, "EVENT_TYPE_IMAGE_IMPORTED": 8, "EVENT_TYPE_IMAGE_REMOVED": 9, } func (x EventType) String() string { return proto.EnumName(EventType_name, int32(x)) } func (EventType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{3} } // ImageFormat defines the format of the image. type ImageFormat struct { // Type of the image, required. Type ImageType `protobuf:"varint,1,opt,name=type,enum=v1alpha.ImageType" json:"type,omitempty"` // Version of the image format, required. Version string `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"` } func (m *ImageFormat) Reset() { *m = ImageFormat{} } func (m *ImageFormat) String() string { return proto.CompactTextString(m) } func (*ImageFormat) ProtoMessage() {} func (*ImageFormat) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } // Image describes the image's information. type Image struct { // Base format of the image, required. This indicates the original format // for the image as nowadays all the image formats will be transformed to // ACI. BaseFormat *ImageFormat `protobuf:"bytes,1,opt,name=base_format" json:"base_format,omitempty"` // ID of the image, a string that can be used to uniquely identify the image, // e.g. sha512 hash of the ACIs, required. Id string `protobuf:"bytes,2,opt,name=id" json:"id,omitempty"` // Name of the image in the image manifest, e.g. 'coreos.com/etcd', optional. Name string `protobuf:"bytes,3,opt,name=name" json:"name,omitempty"` // Version of the image, e.g. 'latest', '2.0.10', optional. Version string `protobuf:"bytes,4,opt,name=version" json:"version,omitempty"` // Timestamp of when the image is imported, it is the seconds since epoch, optional. ImportTimestamp int64 `protobuf:"varint,5,opt,name=import_timestamp" json:"import_timestamp,omitempty"` // JSON-encoded byte array that represents the image manifest, optional. Manifest []byte `protobuf:"bytes,6,opt,name=manifest,proto3" json:"manifest,omitempty"` // Size is the size in bytes of this image in the store. Size int64 `protobuf:"varint,7,opt,name=size" json:"size,omitempty"` // Annotations on this image. Annotations []*KeyValue `protobuf:"bytes,8,rep,name=annotations" json:"annotations,omitempty"` } func (m *Image) Reset() { *m = Image{} } func (m *Image) String() string { return proto.CompactTextString(m) } func (*Image) ProtoMessage() {} func (*Image) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} } func (m *Image) GetBaseFormat() *ImageFormat { if m != nil { return m.BaseFormat } return nil } func (m *Image) GetAnnotations() []*KeyValue { if m != nil { return m.Annotations } return nil } // Network describes the network information of a pod. type Network struct { // Name of the network that a pod belongs to, required. Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` // Pod's IPv4 address within the network, optional if IPv6 address is given. Ipv4 string `protobuf:"bytes,2,opt,name=ipv4" json:"ipv4,omitempty"` // Pod's IPv6 address within the network, optional if IPv4 address is given. Ipv6 string `protobuf:"bytes,3,opt,name=ipv6" json:"ipv6,omitempty"` } func (m *Network) Reset() { *m = Network{} } func (m *Network) String() string { return proto.CompactTextString(m) } func (*Network) ProtoMessage() {} func (*Network) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} } // App describes the information of an app that's running in a pod. type App struct { // Name of the app, required. Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"` // Image used by the app, required. However, this may only contain the image id // if it is returned by ListPods(). Image *Image `protobuf:"bytes,2,opt,name=image" json:"image,omitempty"` // State of the app. optional, non-empty only if it's returned by InspectPod(). State AppState `protobuf:"varint,3,opt,name=state,enum=v1alpha.AppState" json:"state,omitempty"` // Exit code of the app. optional, only valid if it's returned by InspectPod() and // the app has already exited. ExitCode int32 `protobuf:"zigzag32,4,opt,name=exit_code" json:"exit_code,omitempty"` // Annotations for this app. Annotations []*KeyValue `protobuf:"bytes,5,rep,name=annotations" json:"annotations,omitempty"` } func (m *App) Reset() { *m = App{} } func (m *App) String() string { return proto.CompactTextString(m) } func (*App) ProtoMessage() {} func (*App) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} } func (m *App) GetImage() *Image { if m != nil { return m.Image } return nil } func (m *App) GetAnnotations() []*KeyValue { if m != nil { return m.Annotations } return nil } // Pod describes a pod's information. // If a pod is in Embryo, Preparing, AbortedPrepare state, // only id and state will be returned. // // If a pod is in other states, the pod manifest and // apps will be returned when 'detailed' is true in the request. // // A valid pid of the stage1 process of the pod will be returned // if the pod is Running has run once. // // Networks are only returned when a pod is in Running. type Pod struct { // ID of the pod, in the form of a UUID. Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"` // PID of the stage1 process of the pod. Pid int32 `protobuf:"zigzag32,2,opt,name=pid" json:"pid,omitempty"` // State of the pod. State PodState `protobuf:"varint,3,opt,name=state,enum=v1alpha.PodState" json:"state,omitempty"` // List of apps in the pod. Apps []*App `protobuf:"bytes,4,rep,name=apps" json:"apps,omitempty"` // Network information of the pod. // Note that a pod can be in multiple networks. Networks []*Network `protobuf:"bytes,5,rep,name=networks" json:"networks,omitempty"` // JSON-encoded byte array that represents the pod manifest of the pod. Manifest []byte `protobuf:"bytes,6,opt,name=manifest,proto3" json:"manifest,omitempty"` // Annotations on this pod. Annotations []*KeyValue `protobuf:"bytes,7,rep,name=annotations" json:"annotations,omitempty"` // Cgroup of the pod, empty if the pod is not running. Cgroup string `protobuf:"bytes,8,opt,name=cgroup" json:"cgroup,omitempty"` // Timestamp of when the pod is created, nanoseconds since epoch. // Zero if the pod is not created. CreatedAt int64 `protobuf:"varint,9,opt,name=created_at" json:"created_at,omitempty"` // Timestamp of when the pod is started, nanoseconds since epoch. // Zero if the pod is not started. StartedAt int64 `protobuf:"varint,10,opt,name=started_at" json:"started_at,omitempty"` // Timestamp of when the pod is moved to exited-garbage/garbage, // in nanoseconds since epoch. // Zero if the pod is not moved to exited-garbage/garbage yet. GcMarkedAt int64 `protobuf:"varint,11,opt,name=gc_marked_at" json:"gc_marked_at,omitempty"` } func (m *Pod) Reset() { *m = Pod{} } func (m *Pod) String() string { return proto.CompactTextString(m) } func (*Pod) ProtoMessage() {} func (*Pod) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} } func (m *Pod) GetApps() []*App { if m != nil { return m.Apps } return nil } func (m *Pod) GetNetworks() []*Network { if m != nil { return m.Networks } return nil } func (m *Pod) GetAnnotations() []*KeyValue { if m != nil { return m.Annotations } return nil } type KeyValue struct { // Key part of the key-value pair. Key string `protobuf:"bytes,1,opt,name=Key" json:"Key,omitempty"` // Value part of the key-value pair. Value string `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"` } func (m *KeyValue) Reset() { *m = KeyValue{} } func (m *KeyValue) String() string { return proto.CompactTextString(m) } func (*KeyValue) ProtoMessage() {} func (*KeyValue) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} } // PodFilter defines the condition that the returned pods need to satisfy in ListPods(). // The conditions are combined by 'AND', and different filters are combined by 'OR'. type PodFilter struct { // If not empty, the pods that have any of the ids will be returned. Ids []string `protobuf:"bytes,1,rep,name=ids" json:"ids,omitempty"` // If not empty, the pods that have any of the states will be returned. States []PodState `protobuf:"varint,2,rep,name=states,enum=v1alpha.PodState" json:"states,omitempty"` // If not empty, the pods that all of the apps will be returned. AppNames []string `protobuf:"bytes,3,rep,name=app_names" json:"app_names,omitempty"` // If not empty, the pods that have all of the images(in the apps) will be returned ImageIds []string `protobuf:"bytes,4,rep,name=image_ids" json:"image_ids,omitempty"` // If not empty, the pods that are in all of the networks will be returned. NetworkNames []string `protobuf:"bytes,5,rep,name=network_names" json:"network_names,omitempty"` // If not empty, the pods that have all of the annotations will be returned. Annotations []*KeyValue `protobuf:"bytes,6,rep,name=annotations" json:"annotations,omitempty"` // If not empty, the pods whose cgroup are listed will be returned. Cgroups []string `protobuf:"bytes,7,rep,name=cgroups" json:"cgroups,omitempty"` // If not empty, the pods whose these cgroup belong to will be returned. // i.e. the pod's cgroup is a prefix of the specified cgroup PodSubCgroups []string `protobuf:"bytes,8,rep,name=pod_sub_cgroups" json:"pod_sub_cgroups,omitempty"` } func (m *PodFilter) Reset() { *m = PodFilter{} } func (m *PodFilter) String() string { return proto.CompactTextString(m) } func (*PodFilter) ProtoMessage() {} func (*PodFilter) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} } func (m *PodFilter) GetAnnotations() []*KeyValue { if m != nil { return m.Annotations } return nil } // ImageFilter defines the condition that the returned images need to satisfy in ListImages(). // The conditions are combined by 'AND', and different filters are combined by 'OR'. type ImageFilter struct { // If not empty, the images that have any of the ids will be returned. Ids []string `protobuf:"bytes,1,rep,name=ids" json:"ids,omitempty"` // if not empty, the images that have any of the prefixes in the name will be returned. Prefixes []string `protobuf:"bytes,2,rep,name=prefixes" json:"prefixes,omitempty"` // If not empty, the images that have any of the base names will be returned. // For example, both 'coreos.com/etcd' and 'k8s.io/etcd' will be returned if 'etcd' is included, // however 'k8s.io/etcd-backup' will not be returned. BaseNames []string `protobuf:"bytes,3,rep,name=base_names" json:"base_names,omitempty"` // If not empty, the images that have any of the keywords in the name will be returned. // For example, both 'kubernetes-etcd', 'etcd:latest' will be returned if 'etcd' is included, Keywords []string `protobuf:"bytes,4,rep,name=keywords" json:"keywords,omitempty"` // If not empty, the images that have all of the labels will be returned. Labels []*KeyValue `protobuf:"bytes,5,rep,name=labels" json:"labels,omitempty"` // If set, the images that are imported after this timestamp will be returned. ImportedAfter int64 `protobuf:"varint,6,opt,name=imported_after" json:"imported_after,omitempty"` // If set, the images that are imported before this timestamp will be returned. ImportedBefore int64 `protobuf:"varint,7,opt,name=imported_before" json:"imported_before,omitempty"` // If not empty, the images that have all of the annotations will be returned. Annotations []*KeyValue `protobuf:"bytes,8,rep,name=annotations" json:"annotations,omitempty"` // If not empty, the images that have any of the exact full names will be returned. FullNames []string `protobuf:"bytes,9,rep,name=full_names" json:"full_names,omitempty"` } func (m *ImageFilter) Reset() { *m = ImageFilter{} } func (m *ImageFilter) String() string { return proto.CompactTextString(m) } func (*ImageFilter) ProtoMessage() {} func (*ImageFilter) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} } func (m *ImageFilter) GetLabels() []*KeyValue { if m != nil { return m.Labels } return nil } func (m *ImageFilter) GetAnnotations() []*KeyValue { if m != nil { return m.Annotations } return nil } // GlobalFlags describes the flags that passed to rkt api service when it is launched. type GlobalFlags struct { // Data directory. Dir string `protobuf:"bytes,1,opt,name=dir" json:"dir,omitempty"` // System configuration directory. SystemConfigDir string `protobuf:"bytes,2,opt,name=system_config_dir" json:"system_config_dir,omitempty"` // Local configuration directory. LocalConfigDir string `protobuf:"bytes,3,opt,name=local_config_dir" json:"local_config_dir,omitempty"` // User configuration directory. UserConfigDir string `protobuf:"bytes,4,opt,name=user_config_dir" json:"user_config_dir,omitempty"` // Insecure flags configurates what security features to disable. InsecureFlags string `protobuf:"bytes,5,opt,name=insecure_flags" json:"insecure_flags,omitempty"` // Whether to automatically trust gpg keys fetched from https TrustKeysFromHttps bool `protobuf:"varint,6,opt,name=trust_keys_from_https" json:"trust_keys_from_https,omitempty"` } func (m *GlobalFlags) Reset() { *m = GlobalFlags{} } func (m *GlobalFlags) String() string { return proto.CompactTextString(m) } func (*GlobalFlags) ProtoMessage() {} func (*GlobalFlags) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} } // Info describes the information of rkt on the machine. type Info struct { // Version of rkt, required, in the form of Semantic Versioning 2.0.0 (http://semver.org/). RktVersion string `protobuf:"bytes,1,opt,name=rkt_version" json:"rkt_version,omitempty"` // Version of appc, required, in the form of Semantic Versioning 2.0.0 (http://semver.org/). AppcVersion string `protobuf:"bytes,2,opt,name=appc_version" json:"appc_version,omitempty"` // Latest version of the api that's supported by the service, required, in the form of Semantic Versioning 2.0.0 (http://semver.org/). ApiVersion string `protobuf:"bytes,3,opt,name=api_version" json:"api_version,omitempty"` // The global flags that passed to the rkt api service when it's launched. GlobalFlags *GlobalFlags `protobuf:"bytes,4,opt,name=global_flags" json:"global_flags,omitempty"` } func (m *Info) Reset() { *m = Info{} } func (m *Info) String() string { return proto.CompactTextString(m) } func (*Info) ProtoMessage() {} func (*Info) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} } func (m *Info) GetGlobalFlags() *GlobalFlags { if m != nil { return m.GlobalFlags } return nil } // Event describes the events that will be received via ListenEvents(). type Event struct { // Type of the event, required. Type EventType `protobuf:"varint,1,opt,name=type,enum=v1alpha.EventType" json:"type,omitempty"` // ID of the subject that causes the event, required. // If the event is a pod or app event, the id is the pod's uuid. // If the event is an image event, the id is the image's id. Id string `protobuf:"bytes,2,opt,name=id" json:"id,omitempty"` // Name of the subject that causes the event, required. // If the event is a pod event, the name is the pod's name. // If the event is an app event, the name is the app's name. // If the event is an image event, the name is the image's name. From string `protobuf:"bytes,3,opt,name=from" json:"from,omitempty"` // Timestamp of when the event happens, it is the seconds since epoch, required. Time int64 `protobuf:"varint,4,opt,name=time" json:"time,omitempty"` // Data of the event, in the form of key-value pairs, optional. Data []*KeyValue `protobuf:"bytes,5,rep,name=data" json:"data,omitempty"` } func (m *Event) Reset() { *m = Event{} } func (m *Event) String() string { return proto.CompactTextString(m) } func (*Event) ProtoMessage() {} func (*Event) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} } func (m *Event) GetData() []*KeyValue { if m != nil { return m.Data } return nil } // EventFilter defines the condition that the returned events needs to satisfy in ListImages(). // The condition are combined by 'AND'. type EventFilter struct { // If not empty, then only returns the events that have the listed types. Types []EventType `protobuf:"varint,1,rep,name=types,enum=v1alpha.EventType" json:"types,omitempty"` // If not empty, then only returns the events whose 'id' is included in the listed ids. Ids []string `protobuf:"bytes,2,rep,name=ids" json:"ids,omitempty"` // If not empty, then only returns the events whose 'from' is included in the listed names. Names []string `protobuf:"bytes,3,rep,name=names" json:"names,omitempty"` // If set, then only returns the events after this timestamp. // If the server starts after since_time, then only the events happened after the start of the server will be returned. // If since_time is a future timestamp, then no events will be returned until that time. SinceTime int64 `protobuf:"varint,4,opt,name=since_time" json:"since_time,omitempty"` // If set, then only returns the events before this timestamp. // If it is a future timestamp, then the event stream will be closed at that moment. UntilTime int64 `protobuf:"varint,5,opt,name=until_time" json:"until_time,omitempty"` } func (m *EventFilter) Reset() { *m = EventFilter{} } func (m *EventFilter) String() string { return proto.CompactTextString(m) } func (*EventFilter) ProtoMessage() {} func (*EventFilter) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} } // Request for GetInfo(). type GetInfoRequest struct { } func (m *GetInfoRequest) Reset() { *m = GetInfoRequest{} } func (m *GetInfoRequest) String() string { return proto.CompactTextString(m) } func (*GetInfoRequest) ProtoMessage() {} func (*GetInfoRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} } // Response for GetInfo(). type GetInfoResponse struct { Info *Info `protobuf:"bytes,1,opt,name=info" json:"info,omitempty"` } func (m *GetInfoResponse) Reset() { *m = GetInfoResponse{} } func (m *GetInfoResponse) String() string { return proto.CompactTextString(m) } func (*GetInfoResponse) ProtoMessage() {} func (*GetInfoResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} } func (m *GetInfoResponse) GetInfo() *Info { if m != nil { return m.Info } return nil } // Request for ListPods(). type ListPodsRequest struct { Filters []*PodFilter `protobuf:"bytes,1,rep,name=filters" json:"filters,omitempty"` Detail bool `protobuf:"varint,2,opt,name=detail" json:"detail,omitempty"` } func (m *ListPodsRequest) Reset() { *m = ListPodsRequest{} } func (m *ListPodsRequest) String() string { return proto.CompactTextString(m) } func (*ListPodsRequest) ProtoMessage() {} func (*ListPodsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} } func (m *ListPodsRequest) GetFilters() []*PodFilter { if m != nil { return m.Filters } return nil } // Response for ListPods(). type ListPodsResponse struct { Pods []*Pod `protobuf:"bytes,1,rep,name=pods" json:"pods,omitempty"` } func (m *ListPodsResponse) Reset() { *m = ListPodsResponse{} } func (m *ListPodsResponse) String() string { return proto.CompactTextString(m) } func (*ListPodsResponse) ProtoMessage() {} func (*ListPodsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} } func (m *ListPodsResponse) GetPods() []*Pod { if m != nil { return m.Pods } return nil } // Request for InspectPod(). type InspectPodRequest struct { // ID of the pod which we are querying status for, required. Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"` } func (m *InspectPodRequest) Reset() { *m = InspectPodRequest{} } func (m *InspectPodRequest) String() string { return proto.CompactTextString(m) } func (*InspectPodRequest) ProtoMessage() {} func (*InspectPodRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} } // Response for InspectPod(). type InspectPodResponse struct { Pod *Pod `protobuf:"bytes,1,opt,name=pod" json:"pod,omitempty"` } func (m *InspectPodResponse) Reset() { *m = InspectPodResponse{} } func (m *InspectPodResponse) String() string { return proto.CompactTextString(m) } func (*InspectPodResponse) ProtoMessage() {} func (*InspectPodResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} } func (m *InspectPodResponse) GetPod() *Pod { if m != nil { return m.Pod } return nil } // Request for ListImages(). type ListImagesRequest struct { Filters []*ImageFilter `protobuf:"bytes,1,rep,name=filters" json:"filters,omitempty"` Detail bool `protobuf:"varint,2,opt,name=detail" json:"detail,omitempty"` } func (m *ListImagesRequest) Reset() { *m = ListImagesRequest{} } func (m *ListImagesRequest) String() string { return proto.CompactTextString(m) } func (*ListImagesRequest) ProtoMessage() {} func (*ListImagesRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} } func (m *ListImagesRequest) GetFilters() []*ImageFilter { if m != nil { return m.Filters } return nil } // Response for ListImages(). type ListImagesResponse struct { Images []*Image `protobuf:"bytes,1,rep,name=images" json:"images,omitempty"` } func (m *ListImagesResponse) Reset() { *m = ListImagesResponse{} } func (m *ListImagesResponse) String() string { return proto.CompactTextString(m) } func (*ListImagesResponse) ProtoMessage() {} func (*ListImagesResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} } func (m *ListImagesResponse) GetImages() []*Image { if m != nil { return m.Images } return nil } // Request for InspectImage(). type InspectImageRequest struct { Id string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"` } func (m *InspectImageRequest) Reset() { *m = InspectImageRequest{} } func (m *InspectImageRequest) String() string { return proto.CompactTextString(m) } func (*InspectImageRequest) ProtoMessage() {} func (*InspectImageRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} } // Response for InspectImage(). type InspectImageResponse struct { Image *Image `protobuf:"bytes,1,opt,name=image" json:"image,omitempty"` } func (m *InspectImageResponse) Reset() { *m = InspectImageResponse{} } func (m *InspectImageResponse) String() string { return proto.CompactTextString(m) } func (*InspectImageResponse) ProtoMessage() {} func (*InspectImageResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} } func (m *InspectImageResponse) GetImage() *Image { if m != nil { return m.Image } return nil } // Request for ListenEvents(). type ListenEventsRequest struct { Filter *EventFilter `protobuf:"bytes,1,opt,name=filter" json:"filter,omitempty"` } func (m *ListenEventsRequest) Reset() { *m = ListenEventsRequest{} } func (m *ListenEventsRequest) String() string { return proto.CompactTextString(m) } func (*ListenEventsRequest) ProtoMessage() {} func (*ListenEventsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} } func (m *ListenEventsRequest) GetFilter() *EventFilter { if m != nil { return m.Filter } return nil } // Response for ListenEvents(). type ListenEventsResponse struct { // Aggregate multiple events to reduce round trips, optional as the response can contain no events. Events []*Event `protobuf:"bytes,1,rep,name=events" json:"events,omitempty"` } func (m *ListenEventsResponse) Reset() { *m = ListenEventsResponse{} } func (m *ListenEventsResponse) String() string { return proto.CompactTextString(m) } func (*ListenEventsResponse) ProtoMessage() {} func (*ListenEventsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{23} } func (m *ListenEventsResponse) GetEvents() []*Event { if m != nil { return m.Events } return nil } // Request for GetLogs(). type GetLogsRequest struct { // ID of the pod which we will get logs from, required. PodId string `protobuf:"bytes,1,opt,name=pod_id" json:"pod_id,omitempty"` // Name of the app within the pod which we will get logs // from, optional. If not set, then the logs of all the // apps within the pod will be returned. AppName string `protobuf:"bytes,2,opt,name=app_name" json:"app_name,omitempty"` // Number of most recent lines to return, optional. Lines int32 `protobuf:"varint,3,opt,name=lines" json:"lines,omitempty"` // If true, then a response stream will not be closed, // and new log response will be sent via the stream, default is false. Follow bool `protobuf:"varint,4,opt,name=follow" json:"follow,omitempty"` // If set, then only the logs after the timestamp will // be returned, optional. SinceTime int64 `protobuf:"varint,5,opt,name=since_time" json:"since_time,omitempty"` // If set, then only the logs before the timestamp will // be returned, optional. UntilTime int64 `protobuf:"varint,6,opt,name=until_time" json:"until_time,omitempty"` } func (m *GetLogsRequest) Reset() { *m = GetLogsRequest{} } func (m *GetLogsRequest) String() string { return proto.CompactTextString(m) } func (*GetLogsRequest) ProtoMessage() {} func (*GetLogsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{24} } // Response for GetLogs(). type GetLogsResponse struct { // List of the log lines that returned, optional as the response can contain no logs. Lines []string `protobuf:"bytes,1,rep,name=lines" json:"lines,omitempty"` } func (m *GetLogsResponse) Reset() { *m = GetLogsResponse{} } func (m *GetLogsResponse) String() string { return proto.CompactTextString(m) } func (*GetLogsResponse) ProtoMessage() {} func (*GetLogsResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{25} } func init() { proto.RegisterType((*ImageFormat)(nil), "v1alpha.ImageFormat") proto.RegisterType((*Image)(nil), "v1alpha.Image") proto.RegisterType((*Network)(nil), "v1alpha.Network") proto.RegisterType((*App)(nil), "v1alpha.App") proto.RegisterType((*Pod)(nil), "v1alpha.Pod") proto.RegisterType((*KeyValue)(nil), "v1alpha.KeyValue") proto.RegisterType((*PodFilter)(nil), "v1alpha.PodFilter") proto.RegisterType((*ImageFilter)(nil), "v1alpha.ImageFilter") proto.RegisterType((*GlobalFlags)(nil), "v1alpha.GlobalFlags") proto.RegisterType((*Info)(nil), "v1alpha.Info") proto.RegisterType((*Event)(nil), "v1alpha.Event") proto.RegisterType((*EventFilter)(nil), "v1alpha.EventFilter") proto.RegisterType((*GetInfoRequest)(nil), "v1alpha.GetInfoRequest") proto.RegisterType((*GetInfoResponse)(nil), "v1alpha.GetInfoResponse") proto.RegisterType((*ListPodsRequest)(nil), "v1alpha.ListPodsRequest") proto.RegisterType((*ListPodsResponse)(nil), "v1alpha.ListPodsResponse") proto.RegisterType((*InspectPodRequest)(nil), "v1alpha.InspectPodRequest") proto.RegisterType((*InspectPodResponse)(nil), "v1alpha.InspectPodResponse") proto.RegisterType((*ListImagesRequest)(nil), "v1alpha.ListImagesRequest") proto.RegisterType((*ListImagesResponse)(nil), "v1alpha.ListImagesResponse") proto.RegisterType((*InspectImageRequest)(nil), "v1alpha.InspectImageRequest") proto.RegisterType((*InspectImageResponse)(nil), "v1alpha.InspectImageResponse") proto.RegisterType((*ListenEventsRequest)(nil), "v1alpha.ListenEventsRequest") proto.RegisterType((*ListenEventsResponse)(nil), "v1alpha.ListenEventsResponse") proto.RegisterType((*GetLogsRequest)(nil), "v1alpha.GetLogsRequest") proto.RegisterType((*GetLogsResponse)(nil), "v1alpha.GetLogsResponse") proto.RegisterEnum("v1alpha.ImageType", ImageType_name, ImageType_value) proto.RegisterEnum("v1alpha.AppState", AppState_name, AppState_value) proto.RegisterEnum("v1alpha.PodState", PodState_name, PodState_value) proto.RegisterEnum("v1alpha.EventType", EventType_name, EventType_value) } // Reference imports to suppress errors if they are not otherwise used. var _ context.Context var _ grpc.ClientConn // Client API for PublicAPI service type PublicAPIClient interface { // GetInfo gets the rkt's information on the machine. GetInfo(ctx context.Context, in *GetInfoRequest, opts ...grpc.CallOption) (*GetInfoResponse, error) // ListPods lists rkt pods on the machine. ListPods(ctx context.Context, in *ListPodsRequest, opts ...grpc.CallOption) (*ListPodsResponse, error) // InspectPod gets detailed pod information of the specified pod. InspectPod(ctx context.Context, in *InspectPodRequest, opts ...grpc.CallOption) (*InspectPodResponse, error) // ListImages lists the images on the machine. ListImages(ctx context.Context, in *ListImagesRequest, opts ...grpc.CallOption) (*ListImagesResponse, error) // InspectImage gets the detailed image information of the specified image. InspectImage(ctx context.Context, in *InspectImageRequest, opts ...grpc.CallOption) (*InspectImageResponse, error) // ListenEvents listens for the events, it will return a response stream // that will contain event objects. ListenEvents(ctx context.Context, in *ListenEventsRequest, opts ...grpc.CallOption) (PublicAPI_ListenEventsClient, error) // GetLogs gets the logs for a pod, if the app is also specified, then only the logs // of the app will be returned. // // If 'follow' in the 'GetLogsRequest' is set to 'true', then the response stream // will not be closed after the first response, the future logs will be sent via // the stream. GetLogs(ctx context.Context, in *GetLogsRequest, opts ...grpc.CallOption) (PublicAPI_GetLogsClient, error) } type publicAPIClient struct { cc *grpc.ClientConn } func NewPublicAPIClient(cc *grpc.ClientConn) PublicAPIClient { return &publicAPIClient{cc} } func (c *publicAPIClient) GetInfo(ctx context.Context, in *GetInfoRequest, opts ...grpc.CallOption) (*GetInfoResponse, error) { out := new(GetInfoResponse) err := grpc.Invoke(ctx, "/v1alpha.PublicAPI/GetInfo", in, out, c.cc, opts...) if err != nil { return nil, err } return out, nil } func (c *publicAPIClient) ListPods(ctx context.Context, in *ListPodsRequest, opts ...grpc.CallOption) (*ListPodsResponse, error) { out := new(ListPodsResponse) err := grpc.Invoke(ctx, "/v1alpha.PublicAPI/ListPods", in, out, c.cc, opts...) if err != nil { return nil, err } return out, nil } func (c *publicAPIClient) InspectPod(ctx context.Context, in *InspectPodRequest, opts ...grpc.CallOption) (*InspectPodResponse, error) { out := new(InspectPodResponse) err := grpc.Invoke(ctx, "/v1alpha.PublicAPI/InspectPod", in, out, c.cc, opts...) if err != nil { return nil, err } return out, nil } func (c *publicAPIClient) ListImages(ctx context.Context, in *ListImagesRequest, opts ...grpc.CallOption) (*ListImagesResponse, error) { out := new(ListImagesResponse) err := grpc.Invoke(ctx, "/v1alpha.PublicAPI/ListImages", in, out, c.cc, opts...) if err != nil { return nil, err } return out, nil } func (c *publicAPIClient) InspectImage(ctx context.Context, in *InspectImageRequest, opts ...grpc.CallOption) (*InspectImageResponse, error) { out := new(InspectImageResponse) err := grpc.Invoke(ctx, "/v1alpha.PublicAPI/InspectImage", in, out, c.cc, opts...) if err != nil { return nil, err } return out, nil } func (c *publicAPIClient) ListenEvents(ctx context.Context, in *ListenEventsRequest, opts ...grpc.CallOption) (PublicAPI_ListenEventsClient, error) { stream, err := grpc.NewClientStream(ctx, &_PublicAPI_serviceDesc.Streams[0], c.cc, "/v1alpha.PublicAPI/ListenEvents", opts...) if err != nil { return nil, err } x := &publicAPIListenEventsClient{stream} if err := x.ClientStream.SendMsg(in); err != nil { return nil, err } if err := x.ClientStream.CloseSend(); err != nil { return nil, err } return x, nil } type PublicAPI_ListenEventsClient interface { Recv() (*ListenEventsResponse, error) grpc.ClientStream } type publicAPIListenEventsClient struct { grpc.ClientStream } func (x *publicAPIListenEventsClient) Recv() (*ListenEventsResponse, error) { m := new(ListenEventsResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *publicAPIClient) GetLogs(ctx context.Context, in *GetLogsRequest, opts ...grpc.CallOption) (PublicAPI_GetLogsClient, error) { stream, err := grpc.NewClientStream(ctx, &_PublicAPI_serviceDesc.Streams[1], c.cc, "/v1alpha.PublicAPI/GetLogs", opts...) if err != nil { return nil, err } x := &publicAPIGetLogsClient{stream} if err := x.ClientStream.SendMsg(in); err != nil { return nil, err } if err := x.ClientStream.CloseSend(); err != nil { return nil, err } return x, nil } type PublicAPI_GetLogsClient interface { Recv() (*GetLogsResponse, error) grpc.ClientStream } type publicAPIGetLogsClient struct { grpc.ClientStream } func (x *publicAPIGetLogsClient) Recv() (*GetLogsResponse, error) { m := new(GetLogsResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } // Server API for PublicAPI service type PublicAPIServer interface { // GetInfo gets the rkt's information on the machine. GetInfo(context.Context, *GetInfoRequest) (*GetInfoResponse, error) // ListPods lists rkt pods on the machine. ListPods(context.Context, *ListPodsRequest) (*ListPodsResponse, error) // InspectPod gets detailed pod information of the specified pod. InspectPod(context.Context, *InspectPodRequest) (*InspectPodResponse, error) // ListImages lists the images on the machine. ListImages(context.Context, *ListImagesRequest) (*ListImagesResponse, error) // InspectImage gets the detailed image information of the specified image. InspectImage(context.Context, *InspectImageRequest) (*InspectImageResponse, error) // ListenEvents listens for the events, it will return a response stream // that will contain event objects. ListenEvents(*ListenEventsRequest, PublicAPI_ListenEventsServer) error // GetLogs gets the logs for a pod, if the app is also specified, then only the logs // of the app will be returned. // // If 'follow' in the 'GetLogsRequest' is set to 'true', then the response stream // will not be closed after the first response, the future logs will be sent via // the stream. GetLogs(*GetLogsRequest, PublicAPI_GetLogsServer) error } func RegisterPublicAPIServer(s *grpc.Server, srv PublicAPIServer) { s.RegisterService(&_PublicAPI_serviceDesc, srv) } func _PublicAPI_GetInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) { in := new(GetInfoRequest) if err := dec(in); err != nil { return nil, err } out, err := srv.(PublicAPIServer).GetInfo(ctx, in) if err != nil { return nil, err } return out, nil } func _PublicAPI_ListPods_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) { in := new(ListPodsRequest) if err := dec(in); err != nil { return nil, err } out, err := srv.(PublicAPIServer).ListPods(ctx, in) if err != nil { return nil, err } return out, nil } func _PublicAPI_InspectPod_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) { in := new(InspectPodRequest) if err := dec(in); err != nil { return nil, err } out, err := srv.(PublicAPIServer).InspectPod(ctx, in) if err != nil { return nil, err } return out, nil } func _PublicAPI_ListImages_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) { in := new(ListImagesRequest) if err := dec(in); err != nil { return nil, err } out, err := srv.(PublicAPIServer).ListImages(ctx, in) if err != nil { return nil, err } return out, nil } func _PublicAPI_InspectImage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error) (interface{}, error) { in := new(InspectImageRequest) if err := dec(in); err != nil { return nil, err } out, err := srv.(PublicAPIServer).InspectImage(ctx, in) if err != nil { return nil, err } return out, nil } func _PublicAPI_ListenEvents_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(ListenEventsRequest) if err := stream.RecvMsg(m); err != nil { return err } return srv.(PublicAPIServer).ListenEvents(m, &publicAPIListenEventsServer{stream}) } type PublicAPI_ListenEventsServer interface { Send(*ListenEventsResponse) error grpc.ServerStream } type publicAPIListenEventsServer struct { grpc.ServerStream } func (x *publicAPIListenEventsServer) Send(m *ListenEventsResponse) error { return x.ServerStream.SendMsg(m) } func _PublicAPI_GetLogs_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(GetLogsRequest) if err := stream.RecvMsg(m); err != nil { return err } return srv.(PublicAPIServer).GetLogs(m, &publicAPIGetLogsServer{stream}) } type PublicAPI_GetLogsServer interface { Send(*GetLogsResponse) error grpc.ServerStream } type publicAPIGetLogsServer struct { grpc.ServerStream } func (x *publicAPIGetLogsServer) Send(m *GetLogsResponse) error { return x.ServerStream.SendMsg(m) } var _PublicAPI_serviceDesc = grpc.ServiceDesc{ ServiceName: "v1alpha.PublicAPI", HandlerType: (*PublicAPIServer)(nil), Methods: []grpc.MethodDesc{ { MethodName: "GetInfo", Handler: _PublicAPI_GetInfo_Handler, }, { MethodName: "ListPods", Handler: _PublicAPI_ListPods_Handler, }, { MethodName: "InspectPod", Handler: _PublicAPI_InspectPod_Handler, }, { MethodName: "ListImages", Handler: _PublicAPI_ListImages_Handler, }, { MethodName: "InspectImage", Handler: _PublicAPI_InspectImage_Handler, }, }, Streams: []grpc.StreamDesc{ { StreamName: "ListenEvents", Handler: _PublicAPI_ListenEvents_Handler, ServerStreams: true, }, { StreamName: "GetLogs", Handler: _PublicAPI_GetLogs_Handler, ServerStreams: true, }, }, } var fileDescriptor0 = []byte{ // 1492 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x94, 0x57, 0xcf, 0x6e, 0xdb, 0xc6, 0x13, 0x8e, 0xfe, 0x4b, 0x23, 0x45, 0x96, 0xd6, 0x4e, 0x2c, 0x2b, 0xff, 0x1c, 0xfe, 0x7e, 0x0d, 0x52, 0x1f, 0xdc, 0xd6, 0x49, 0x73, 0x29, 0x50, 0x44, 0xb1, 0x69, 0x43, 0x8d, 0x2d, 0x09, 0x8a, 0x62, 0x34, 0x27, 0x82, 0x92, 0x56, 0x0e, 0x61, 0x8a, 0x64, 0x49, 0xca, 0x89, 0x7b, 0xec, 0xa9, 0xb7, 0x3e, 0x42, 0x1f, 0xa3, 0xc7, 0xde, 0xfb, 0x18, 0x05, 0xfa, 0x1e, 0x9d, 0x5d, 0x2e, 0xc9, 0x25, 0x45, 0x1d, 0x7a, 0xb3, 0x66, 0x66, 0xbf, 0xf9, 0x66, 0x76, 0xe6, 0x5b, 0x1a, 0x6a, 0xba, 0x63, 0x1c, 0x3a, 0xae, 0xed, 0xdb, 0xa4, 0x72, 0xf3, 0x8d, 0x6e, 0x3a, 0x1f, 0x75, 0xe5, 0x35, 0xd4, 0xfb, 0x4b, 0xfd, 0x8a, 0x9e, 0xda, 0xee, 0x52, 0xf7, 0xc9, 0x3e, 0x14, 0xfd, 0x5b, 0x87, 0x76, 0x72, 0xfb, 0xb9, 0xe7, 0xcd, 0x23, 0x72, 0x28, 0xc2, 0x0e, 0x79, 0xcc, 0x04, 0x3d, 0x64, 0x0b, 0x2a, 0x37, 0xd4, 0xf5, 0x0c, 0xdb, 0xea, 0xe4, 0x31, 0xa8, 0xa6, 0xfc, 0x99, 0x83, 0x12, 0x77, 0x93, 0x2f, 0xa1, 0x3e, 0xd5, 0x3d, 0xaa, 0x2d, 0x38, 0x16, 0xc7, 0xa8, 0x1f, 0xed, 0x24, 0x31, 0x44, 0x1e, 0x80, 0xbc, 0x31, 0x0f, 0x00, 0x48, 0x03, 0x8a, 0x96, 0xbe, 0xa4, 0x9d, 0x02, 0xff, 0x25, 0xe1, 0x17, 0xb9, 0xa1, 0x03, 0x2d, 0x63, 0xe9, 0xd8, 0xae, 0xaf, 0xf9, 0xc6, 0x92, 0x7a, 0xbe, 0xbe, 0x74, 0x3a, 0x25, 0xf4, 0x14, 0x48, 0x0b, 0xaa, 0x4b, 0xdd, 0x32, 0x16, 0x68, 0xec, 0x94, 0xd1, 0xd2, 0x60, 0x50, 0x9e, 0xf1, 0x33, 0xed, 0x54, 0xb8, 0xff, 0x19, 0xd4, 0x75, 0xcb, 0xb2, 0x7d, 0xdd, 0x47, 0x34, 0xaf, 0x53, 0xdd, 0x2f, 0x20, 0x9f, 0x76, 0xc4, 0xe7, 0x2d, 0xbd, 0xbd, 0xd4, 0xcd, 0x15, 0x55, 0x5e, 0x40, 0x65, 0x40, 0xfd, 0x4f, 0xb6, 0x7b, 0x1d, 0x71, 0xc9, 0x85, 0xcc, 0x0c, 0xe7, 0xe6, 0x65, 0xcc, 0x13, 0x7f, 0xbd, 0x0a, 0x78, 0x2a, 0xbf, 0xe5, 0xa0, 0xd0, 0x73, 0x9c, 0xd4, 0x89, 0x47, 0x50, 0x32, 0x58, 0x99, 0xfc, 0x48, 0xfd, 0xa8, 0x99, 0x2c, 0x1e, 0xdb, 0x5b, 0xc2, 0x02, 0xfc, 0xa0, 0xd6, 0xa6, 0xc4, 0x05, 0x91, 0xde, 0x31, 0x07, 0x69, 0x43, 0x8d, 0x7e, 0x36, 0x7c, 0x6d, 0x66, 0xcf, 0x29, 0x6f, 0x40, 0x3b, 0x5d, 0x46, 0x69, 0x53, 0x19, 0xbf, 0xe6, 0xa1, 0x30, 0xb2, 0xe7, 0xa2, 0xb7, 0x01, 0x9f, 0x3a, 0x14, 0x1c, 0xd1, 0xe8, 0xf6, 0xe6, 0xec, 0x78, 0x2a, 0xc8, 0xde, 0x85, 0xa2, 0xee, 0x38, 0x1e, 0x26, 0x66, 0x39, 0x1a, 0x32, 0x3d, 0xa2, 0x40, 0xd5, 0x0a, 0xba, 0x14, 0x72, 0x68, 0x45, 0xfe, 0xb0, 0x7d, 0xeb, 0x37, 0x92, 0x22, 0x5f, 0xd9, 0x40, 0x9e, 0x34, 0xa1, 0x3c, 0xbb, 0x72, 0xed, 0x95, 0x83, 0xd7, 0xc4, 0x88, 0x63, 0x15, 0x33, 0x97, 0x22, 0xa7, 0xb9, 0x86, 0xa3, 0x54, 0xe3, 0xf7, 0x89, 0x36, 0xe4, 0xef, 0x0a, 0x1b, 0x70, 0xdb, 0x0e, 0x34, 0xae, 0x66, 0xda, 0x52, 0x77, 0xaf, 0x03, 0x6b, 0x9d, 0x59, 0x95, 0x67, 0x50, 0x8d, 0x90, 0xb1, 0x05, 0xf8, 0xb7, 0xe8, 0xc7, 0x5d, 0x28, 0xdd, 0x30, 0xab, 0x98, 0xdd, 0xbf, 0x72, 0x50, 0xc3, 0xe2, 0x4f, 0x0d, 0xd3, 0xa7, 0x2e, 0x8b, 0x34, 0xe6, 0x1e, 0x46, 0x16, 0x30, 0xf2, 0x29, 0x94, 0x79, 0xb3, 0x3c, 0x0c, 0x2d, 0x64, 0x77, 0xab, 0xcd, 0x36, 0xca, 0xd1, 0xd8, 0xf5, 0x7b, 0xd8, 0x53, 0x76, 0x0a, 0x4d, 0xfc, 0xfe, 0x35, 0x06, 0x54, 0xe4, 0xa6, 0x7b, 0x70, 0x57, 0xf4, 0x4d, 0x44, 0x96, 0xb8, 0x39, 0xd5, 0x98, 0xf2, 0xa6, 0xc6, 0xe0, 0x3e, 0x04, 0x8d, 0x09, 0x9a, 0x57, 0x23, 0xbb, 0xb0, 0xe5, 0xd8, 0x73, 0xcd, 0x5b, 0x4d, 0xb5, 0xd0, 0xc1, 0x26, 0xbb, 0xa6, 0xfc, 0x9d, 0x0b, 0x77, 0x39, 0xa3, 0x1c, 0xbc, 0x19, 0xc7, 0xa5, 0x0b, 0xe3, 0xb3, 0x28, 0x88, 0x77, 0x98, 0x6f, 0xab, 0x4c, 0x1f, 0xa3, 0xae, 0xe9, 0x2d, 0x72, 0x8d, 0xd8, 0x63, 0x1b, 0x4c, 0x7d, 0x4a, 0xcd, 0xcd, 0x73, 0x47, 0xee, 0x43, 0x33, 0x58, 0x50, 0x76, 0x03, 0x0b, 0xcc, 0xcc, 0xaf, 0xbe, 0xc0, 0x88, 0x46, 0xf6, 0x29, 0x45, 0x51, 0xf8, 0x8f, 0x7b, 0xc9, 0x18, 0x2e, 0x56, 0xa6, 0x29, 0x18, 0xd6, 0x78, 0x91, 0xbf, 0x63, 0x91, 0x67, 0xa6, 0x3d, 0xd5, 0xcd, 0x53, 0x53, 0xbf, 0xf2, 0x58, 0x91, 0x73, 0xc3, 0x15, 0xb7, 0xbb, 0x07, 0x6d, 0xef, 0xd6, 0xf3, 0xe9, 0x12, 0xd7, 0xc7, 0x5a, 0x18, 0x57, 0x1a, 0x73, 0xe5, 0x43, 0x15, 0x31, 0xed, 0x99, 0x6e, 0xca, 0x9e, 0x40, 0x70, 0x90, 0xe6, 0xca, 0xa3, 0xae, 0xec, 0x08, 0x84, 0x87, 0xd5, 0x65, 0x79, 0x74, 0xb6, 0x72, 0x51, 0xd2, 0x58, 0x32, 0x2e, 0x3b, 0x6c, 0xc7, 0xef, 0xf9, 0xee, 0xca, 0xf3, 0x35, 0x6c, 0x95, 0xa7, 0x2d, 0x5c, 0x7b, 0xa9, 0x7d, 0xf4, 0x7d, 0xc7, 0xe3, 0x65, 0x57, 0x15, 0x17, 0x8a, 0x7d, 0x6b, 0x61, 0x93, 0x6d, 0xa8, 0xbb, 0xd7, 0xbe, 0x16, 0x8a, 0x59, 0xc0, 0x10, 0xc7, 0x15, 0x47, 0x66, 0xa6, 0x25, 0x24, 0x94, 0x85, 0xa2, 0x34, 0x47, 0xc6, 0x80, 0xd7, 0x01, 0x4e, 0x36, 0x2f, 0x54, 0x24, 0x2f, 0xa6, 0xe4, 0x54, 0xea, 0x02, 0xe6, 0x2c, 0xa9, 0x37, 0xd4, 0xda, 0xac, 0xdf, 0xdc, 0xcb, 0xf5, 0x3b, 0xa5, 0xbc, 0x8c, 0xbe, 0x48, 0x88, 0xbf, 0x98, 0xc2, 0xf2, 0x44, 0x05, 0xf2, 0x04, 0x8a, 0x73, 0xdd, 0xd7, 0x37, 0xcb, 0x8d, 0x0f, 0x75, 0x8e, 0x2a, 0xa6, 0xed, 0x29, 0x94, 0x58, 0xe6, 0x60, 0xde, 0xb2, 0x53, 0x8b, 0x81, 0x0c, 0xc6, 0x0f, 0x37, 0x51, 0x9e, 0x3c, 0xb6, 0xdb, 0x86, 0x35, 0xa3, 0x9a, 0x44, 0x01, 0x6d, 0x2b, 0xcb, 0x37, 0xcc, 0xc0, 0xc6, 0x35, 0x5f, 0x69, 0x41, 0xf3, 0x8c, 0xfa, 0xac, 0xc1, 0x63, 0xfa, 0xd3, 0x0a, 0x75, 0x46, 0x39, 0x84, 0xad, 0xc8, 0xe2, 0x39, 0x38, 0x50, 0x94, 0x3c, 0x40, 0xa5, 0xc6, 0xdf, 0xe2, 0x05, 0xba, 0x1b, 0x8b, 0x30, 0x1a, 0x95, 0x53, 0xd8, 0x3a, 0x37, 0x3c, 0x1f, 0xb7, 0xd8, 0x13, 0x10, 0xe4, 0x7f, 0x50, 0x59, 0xf0, 0x2a, 0x02, 0xf6, 0x75, 0x89, 0x7d, 0xac, 0x0e, 0xa8, 0x50, 0x73, 0xea, 0xeb, 0x86, 0xc9, 0x9b, 0x57, 0xc5, 0xbc, 0xad, 0x18, 0x47, 0x24, 0x46, 0xfd, 0xc4, 0xdd, 0x0c, 0x51, 0x1a, 0x32, 0x8a, 0xf2, 0x04, 0xda, 0x7d, 0xcb, 0x73, 0xe8, 0x8c, 0x1d, 0x09, 0x33, 0x4b, 0x5a, 0xad, 0x7c, 0x05, 0x44, 0x0e, 0x10, 0x90, 0x7b, 0xa8, 0xe0, 0xf6, 0x5c, 0x94, 0x92, 0x44, 0xfc, 0x01, 0xda, 0x8c, 0x01, 0xdf, 0xf9, 0xa8, 0x96, 0x2f, 0xd2, 0xb5, 0xa4, 0x1f, 0xe0, 0xec, 0x6a, 0x5e, 0x02, 0x91, 0xb1, 0x44, 0xf2, 0xc7, 0x50, 0xe6, 0x72, 0x16, 0x62, 0xa5, 0xde, 0x33, 0xe5, 0x29, 0x6c, 0x0b, 0xca, 0xfc, 0x77, 0x56, 0x55, 0xdf, 0xc2, 0x4e, 0x32, 0x44, 0x40, 0x47, 0x2f, 0x65, 0x2e, 0xeb, 0xa5, 0x54, 0xbe, 0x83, 0x6d, 0xc6, 0x87, 0x5a, 0x7c, 0x7c, 0xa2, 0xea, 0xfe, 0x0f, 0xe5, 0xa0, 0xba, 0xb5, 0xaf, 0x0b, 0x69, 0x16, 0x95, 0x57, 0xb0, 0x93, 0x3c, 0x1c, 0x97, 0x43, 0xb9, 0x65, 0xad, 0x1c, 0x1e, 0xa8, 0xdc, 0xf2, 0xe1, 0x3a, 0xb7, 0xaf, 0xa2, 0x7c, 0xd8, 0x26, 0x26, 0xb6, 0xd1, 0x7b, 0x8a, 0x02, 0x19, 0x4a, 0xbe, 0xd8, 0x21, 0x9c, 0x63, 0xd3, 0xb0, 0xf8, 0x1c, 0xe7, 0x9e, 0x97, 0xd8, 0x81, 0x85, 0x6d, 0x9a, 0xf6, 0x27, 0x3e, 0xc3, 0xd5, 0xd4, 0x5c, 0x97, 0x32, 0xe6, 0x9a, 0x8b, 0xa5, 0xb2, 0xcf, 0xa7, 0x38, 0x48, 0x2d, 0xd8, 0x46, 0xc8, 0x5c, 0xc1, 0x0f, 0x28, 0xd4, 0xe2, 0xaf, 0xb0, 0x0e, 0x76, 0xf5, 0xa2, 0x77, 0xa6, 0x6a, 0x93, 0x0f, 0x23, 0x55, 0x7b, 0x3f, 0x38, 0x51, 0x4f, 0xfb, 0x03, 0xf5, 0xa4, 0x75, 0x07, 0xb5, 0x64, 0x4b, 0xf2, 0xf4, 0x46, 0xa3, 0xe3, 0x56, 0x0e, 0xdf, 0xa0, 0xb6, 0x64, 0x3c, 0x19, 0x1e, 0xbf, 0x55, 0xc7, 0xad, 0x3c, 0x12, 0x69, 0x4a, 0xe6, 0xe1, 0x71, 0xbf, 0x55, 0x38, 0x18, 0x41, 0x35, 0xfa, 0x18, 0xd9, 0x85, 0x6d, 0x04, 0xd0, 0xde, 0x4d, 0x7a, 0x93, 0x64, 0x12, 0xc4, 0x8b, 0x1d, 0xe3, 0xf7, 0x83, 0x41, 0x7f, 0x70, 0x86, 0x69, 0x76, 0xa0, 0x15, 0x9b, 0xd5, 0x1f, 0xfb, 0x13, 0x0c, 0xce, 0x1f, 0xfc, 0x93, 0x83, 0x6a, 0xf4, 0x66, 0x22, 0xe4, 0x68, 0x78, 0x92, 0x01, 0x89, 0x67, 0x63, 0x87, 0x7a, 0xf1, 0x66, 0xfc, 0x61, 0x88, 0x88, 0x89, 0xf0, 0xd1, 0x58, 0x1d, 0xf5, 0xc6, 0x2c, 0x55, 0x1e, 0xc5, 0x99, 0xa4, 0x1d, 0x08, 0x53, 0x60, 0xcc, 0x62, 0x7b, 0xc8, 0xac, 0x88, 0xd3, 0xb6, 0x17, 0x9b, 0x7b, 0x6f, 0x86, 0x63, 0xa4, 0x16, 0x1e, 0x6b, 0x95, 0x52, 0xc9, 0x03, 0xe2, 0xe5, 0x64, 0x8e, 0x13, 0xf5, 0x5c, 0x9d, 0x30, 0xb0, 0x4a, 0x32, 0xc7, 0x59, 0x6f, 0xfc, 0x06, 0x5b, 0xd8, 0xaa, 0x1e, 0xfc, 0x91, 0x87, 0x5a, 0x2c, 0x76, 0x78, 0x43, 0xea, 0xa5, 0x3a, 0x98, 0xac, 0xdf, 0xd0, 0x03, 0xd8, 0x95, 0x3c, 0x0c, 0x29, 0xe2, 0x9f, 0xc3, 0xaf, 0xac, 0xc7, 0xd9, 0xce, 0x90, 0x35, 0xd6, 0xde, 0x85, 0xfb, 0xa9, 0x18, 0xa4, 0xc2, 0x7d, 0x05, 0x94, 0x8b, 0x7b, 0x29, 0x9f, 0x28, 0xa7, 0x88, 0xbb, 0xb3, 0x9f, 0x72, 0x09, 0xee, 0xda, 0xf1, 0xf0, 0xfc, 0x5c, 0x3d, 0x66, 0x51, 0xa5, 0x14, 0xb8, 0xb8, 0xce, 0x71, 0xd0, 0x90, 0x24, 0x38, 0xf3, 0x09, 0xf0, 0x0a, 0x6b, 0xb0, 0xe4, 0x0a, 0xa6, 0xaa, 0x7f, 0x31, 0x0a, 0x28, 0x57, 0xc9, 0x43, 0xe8, 0xac, 0xb9, 0xc7, 0xea, 0xc5, 0xf0, 0x12, 0xbd, 0xb5, 0xa3, 0x5f, 0x8a, 0xf8, 0x19, 0xb6, 0x9a, 0x9a, 0xc6, 0xac, 0x37, 0xea, 0x93, 0xef, 0xa1, 0x22, 0x04, 0x9d, 0xec, 0xc6, 0xaf, 0x5d, 0x42, 0xf4, 0xbb, 0x9d, 0x75, 0x47, 0xb0, 0x35, 0xca, 0x1d, 0xd2, 0x83, 0x6a, 0x28, 0xcc, 0x24, 0x8e, 0x4b, 0x69, 0x7e, 0x77, 0x2f, 0xc3, 0x13, 0x41, 0x9c, 0x01, 0xc4, 0x52, 0x4c, 0xba, 0xd2, 0x03, 0x92, 0x12, 0xf0, 0xee, 0x83, 0x4c, 0x9f, 0x0c, 0x14, 0xcb, 0xaa, 0x04, 0xb4, 0xa6, 0xdb, 0x12, 0xd0, 0xba, 0x0e, 0x23, 0xd0, 0x05, 0x34, 0x64, 0x19, 0x25, 0x0f, 0xd3, 0x79, 0x65, 0x01, 0xee, 0x3e, 0xda, 0xe0, 0x8d, 0xe0, 0x86, 0xd0, 0x90, 0x15, 0x52, 0x82, 0xcb, 0x50, 0x5d, 0x09, 0x2e, 0x4b, 0x56, 0x95, 0x3b, 0x5f, 0xe7, 0xc8, 0x6b, 0x7e, 0x69, 0x4c, 0xbf, 0x92, 0x97, 0x26, 0x89, 0x69, 0xf2, 0xd2, 0x64, 0xa9, 0x63, 0x08, 0xd3, 0x32, 0xff, 0xcf, 0xf4, 0xc5, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x4a, 0x23, 0xef, 0x15, 0xa6, 0x0e, 0x00, 0x00, } cadvisor-0.25.0/vendor/github.com/coreos/rkt/api/v1alpha/api.proto000066400000000000000000000427141306035727200250160ustar00rootroot00000000000000// Copyright 2015 The rkt 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. // *************************************************** // // ************ WARNING - HERE BE DRAGONS ************ // // // // The API defined here is proposed, experimental, // // and (for now) subject to change at any time. // // // // If you think you want to use it, or for any other // // queries, contact // // or file an issue on github.com/coreos/rkt // // // // *************************************************** // // ****************** END WARNING ******************** // syntax = "proto3"; package v1alpha; // ImageType defines the supported image type. enum ImageType { IMAGE_TYPE_UNDEFINED = 0; IMAGE_TYPE_APPC = 1; IMAGE_TYPE_DOCKER = 2; IMAGE_TYPE_OCI = 3; } // ImageFormat defines the format of the image. message ImageFormat { // Type of the image, required. ImageType type = 1; // Version of the image format, required. string version = 2; } // Image describes the image's information. message Image { // Base format of the image, required. This indicates the original format // for the image as nowadays all the image formats will be transformed to // ACI. ImageFormat base_format = 1; // ID of the image, a string that can be used to uniquely identify the image, // e.g. sha512 hash of the ACIs, required. string id = 2; // Name of the image in the image manifest, e.g. 'coreos.com/etcd', optional. string name = 3; // Version of the image, e.g. 'latest', '2.0.10', optional. string version = 4; // Timestamp of when the image is imported, it is the seconds since epoch, optional. int64 import_timestamp = 5; // JSON-encoded byte array that represents the image manifest, optional. bytes manifest = 6; // Size is the size in bytes of this image in the store. int64 size = 7; // Annotations on this image. repeated KeyValue annotations = 8; } // Network describes the network information of a pod. message Network { // Name of the network that a pod belongs to, required. string name = 1; // Pod's IPv4 address within the network, optional if IPv6 address is given. string ipv4 = 2; // Pod's IPv6 address within the network, optional if IPv4 address is given. string ipv6 = 3; } // AppState defines the possible states of the app. enum AppState { APP_STATE_UNDEFINED = 0; APP_STATE_RUNNING = 1; APP_STATE_EXITED = 2; } // App describes the information of an app that's running in a pod. message App { // Name of the app, required. string name = 1; // Image used by the app, required. However, this may only contain the image id // if it is returned by ListPods(). Image image = 2; // State of the app. optional, non-empty only if it's returned by InspectPod(). AppState state = 3; // Exit code of the app. optional, only valid if it's returned by InspectPod() and // the app has already exited. sint32 exit_code = 4; // Annotations for this app. repeated KeyValue annotations = 5; } // PodState defines the possible states of the pod. // See https://github.com/coreos/rkt/blob/master/Documentation/devel/pod-lifecycle.md for a detailed // explanation of each state. enum PodState { POD_STATE_UNDEFINED = 0; // States before the pod is running. POD_STATE_EMBRYO = 1; // Pod is created, ready to entering 'preparing' state. POD_STATE_PREPARING = 2; // Pod is being prepared. On success it will become 'prepared', otherwise it will become 'aborted prepared'. POD_STATE_PREPARED = 3; // Pod has been successfully prepared, ready to enter 'running' state. it can also enter 'deleting' if it's garbage collected before running. // State that indicates the pod is running. POD_STATE_RUNNING = 4; // Pod is running, when it exits, it will become 'exited'. // States that indicates the pod is exited, and will never run. POD_STATE_ABORTED_PREPARE = 5; // Pod failed to prepare, it will only be garbage collected and will never run again. POD_STATE_EXITED = 6; // Pod has exited, it now can be garbage collected. POD_STATE_DELETING = 7; // Pod is being garbage collected, after that it will enter 'garbage' state. POD_STATE_GARBAGE = 8; // Pod is marked as garbage collected, it no longer exists on the machine. } // Pod describes a pod's information. // If a pod is in Embryo, Preparing, AbortedPrepare state, // only id and state will be returned. // // If a pod is in other states, the pod manifest and // apps will be returned when 'detailed' is true in the request. // // A valid pid of the stage1 process of the pod will be returned // if the pod is Running has run once. // // Networks are only returned when a pod is in Running. message Pod { // ID of the pod, in the form of a UUID. string id = 1; // PID of the stage1 process of the pod. sint32 pid = 2; // State of the pod. PodState state = 3; // List of apps in the pod. repeated App apps = 4; // Network information of the pod. // Note that a pod can be in multiple networks. repeated Network networks = 5; // JSON-encoded byte array that represents the pod manifest of the pod. bytes manifest = 6; // Annotations on this pod. repeated KeyValue annotations = 7; // Cgroup of the pod, empty if the pod is not running. string cgroup = 8; // Timestamp of when the pod is created, nanoseconds since epoch. // Zero if the pod is not created. int64 created_at = 9; // Timestamp of when the pod is started, nanoseconds since epoch. // Zero if the pod is not started. int64 started_at = 10; // Timestamp of when the pod is moved to exited-garbage/garbage, // in nanoseconds since epoch. // Zero if the pod is not moved to exited-garbage/garbage yet. int64 gc_marked_at = 11; } message KeyValue { // Key part of the key-value pair. string Key = 1; // Value part of the key-value pair. string value = 2; } // PodFilter defines the condition that the returned pods need to satisfy in ListPods(). // The conditions are combined by 'AND', and different filters are combined by 'OR'. message PodFilter { // If not empty, the pods that have any of the ids will be returned. repeated string ids = 1; // If not empty, the pods that have any of the states will be returned. repeated PodState states = 2; // If not empty, the pods that all of the apps will be returned. repeated string app_names = 3; // If not empty, the pods that have all of the images(in the apps) will be returned repeated string image_ids = 4; // If not empty, the pods that are in all of the networks will be returned. repeated string network_names = 5; // If not empty, the pods that have all of the annotations will be returned. repeated KeyValue annotations = 6; // If not empty, the pods whose cgroup are listed will be returned. repeated string cgroups = 7; // If not empty, the pods whose these cgroup belong to will be returned. // i.e. the pod's cgroup is a prefix of the specified cgroup repeated string pod_sub_cgroups = 8; } // ImageFilter defines the condition that the returned images need to satisfy in ListImages(). // The conditions are combined by 'AND', and different filters are combined by 'OR'. message ImageFilter { // If not empty, the images that have any of the ids will be returned. repeated string ids = 1; // if not empty, the images that have any of the prefixes in the name will be returned. repeated string prefixes = 2; // If not empty, the images that have any of the base names will be returned. // For example, both 'coreos.com/etcd' and 'k8s.io/etcd' will be returned if 'etcd' is included, // however 'k8s.io/etcd-backup' will not be returned. repeated string base_names = 3; // If not empty, the images that have any of the keywords in the name will be returned. // For example, both 'kubernetes-etcd', 'etcd:latest' will be returned if 'etcd' is included, repeated string keywords = 4; // If not empty, the images that have all of the labels will be returned. repeated KeyValue labels = 5; // If set, the images that are imported after this timestamp will be returned. int64 imported_after = 6; // If set, the images that are imported before this timestamp will be returned. int64 imported_before = 7; // If not empty, the images that have all of the annotations will be returned. repeated KeyValue annotations = 8; // If not empty, the images that have any of the exact full names will be returned. repeated string full_names = 9; } // GlobalFlags describes the flags that passed to rkt api service when it is launched. message GlobalFlags { // Data directory. string dir = 1; // System configuration directory. string system_config_dir = 2; // Local configuration directory. string local_config_dir = 3; // User configuration directory. string user_config_dir = 4; // Insecure flags configurates what security features to disable. string insecure_flags = 5; // Whether to automatically trust gpg keys fetched from https bool trust_keys_from_https = 6; } // Info describes the information of rkt on the machine. message Info { // Version of rkt, required, in the form of Semantic Versioning 2.0.0 (http://semver.org/). string rkt_version = 1; // Version of appc, required, in the form of Semantic Versioning 2.0.0 (http://semver.org/). string appc_version = 2; // Latest version of the api that's supported by the service, required, in the form of Semantic Versioning 2.0.0 (http://semver.org/). string api_version = 3; // The global flags that passed to the rkt api service when it's launched. GlobalFlags global_flags = 4; } // EventType defines the type of the events that will be received via ListenEvents(). enum EventType { EVENT_TYPE_UNDEFINED = 0; // Pod events. EVENT_TYPE_POD_PREPARED = 1; EVENT_TYPE_POD_PREPARE_ABORTED = 2; EVENT_TYPE_POD_STARTED = 3; EVENT_TYPE_POD_EXITED = 4; EVENT_TYPE_POD_GARBAGE_COLLECTED = 5; // App events. EVENT_TYPE_APP_STARTED = 6; EVENT_TYPE_APP_EXITED = 7; // (XXX)yifan: Maybe also return exit code in the event object? // Image events. EVENT_TYPE_IMAGE_IMPORTED = 8; EVENT_TYPE_IMAGE_REMOVED = 9; } // Event describes the events that will be received via ListenEvents(). message Event { // Type of the event, required. EventType type = 1; // ID of the subject that causes the event, required. // If the event is a pod or app event, the id is the pod's uuid. // If the event is an image event, the id is the image's id. string id = 2; // Name of the subject that causes the event, required. // If the event is a pod event, the name is the pod's name. // If the event is an app event, the name is the app's name. // If the event is an image event, the name is the image's name. string from = 3; // Timestamp of when the event happens, it is the seconds since epoch, required. int64 time = 4; // Data of the event, in the form of key-value pairs, optional. repeated KeyValue data = 5; } // EventFilter defines the condition that the returned events needs to satisfy in ListImages(). // The condition are combined by 'AND'. message EventFilter { // If not empty, then only returns the events that have the listed types. repeated EventType types = 1; // If not empty, then only returns the events whose 'id' is included in the listed ids. repeated string ids = 2; // If not empty, then only returns the events whose 'from' is included in the listed names. repeated string names = 3; // If set, then only returns the events after this timestamp. // If the server starts after since_time, then only the events happened after the start of the server will be returned. // If since_time is a future timestamp, then no events will be returned until that time. int64 since_time = 4; // If set, then only returns the events before this timestamp. // If it is a future timestamp, then the event stream will be closed at that moment. int64 until_time = 5; } // Request for GetInfo(). message GetInfoRequest {} // Response for GetInfo(). message GetInfoResponse { Info info = 1; // Required. } // Request for ListPods(). message ListPodsRequest { repeated PodFilter filters = 1; // Optional. bool detail = 2; // Optional. } // Response for ListPods(). message ListPodsResponse { repeated Pod pods = 1; // Required. } // Request for InspectPod(). message InspectPodRequest { // ID of the pod which we are querying status for, required. string id = 1; } // Response for InspectPod(). message InspectPodResponse { Pod pod = 1; // Required. } // Request for ListImages(). message ListImagesRequest { repeated ImageFilter filters = 1; // Optional. bool detail = 2; // Optional. } // Response for ListImages(). message ListImagesResponse { repeated Image images = 1; // Required. } // Request for InspectImage(). message InspectImageRequest { string id = 1; // Required. } // Response for InspectImage(). message InspectImageResponse { Image image = 1; // Required. } // Request for ListenEvents(). message ListenEventsRequest { EventFilter filter = 1; // Optional. } // Response for ListenEvents(). message ListenEventsResponse { // Aggregate multiple events to reduce round trips, optional as the response can contain no events. repeated Event events = 1; } // Request for GetLogs(). message GetLogsRequest { // ID of the pod which we will get logs from, required. string pod_id = 1; // Name of the app within the pod which we will get logs // from, optional. If not set, then the logs of all the // apps within the pod will be returned. string app_name = 2; // Number of most recent lines to return, optional. int32 lines = 3; // If true, then a response stream will not be closed, // and new log response will be sent via the stream, default is false. bool follow = 4; // If set, then only the logs after the timestamp will // be returned, optional. int64 since_time = 5; // If set, then only the logs before the timestamp will // be returned, optional. int64 until_time = 6; } // Response for GetLogs(). message GetLogsResponse { // List of the log lines that returned, optional as the response can contain no logs. repeated string lines = 1; } // PublicAPI defines the read-only APIs that will be supported. // These will be handled over TCP sockets. service PublicAPI { // GetInfo gets the rkt's information on the machine. rpc GetInfo (GetInfoRequest) returns (GetInfoResponse) {} // ListPods lists rkt pods on the machine. rpc ListPods (ListPodsRequest) returns (ListPodsResponse) {} // InspectPod gets detailed pod information of the specified pod. rpc InspectPod (InspectPodRequest) returns (InspectPodResponse) {} // ListImages lists the images on the machine. rpc ListImages (ListImagesRequest) returns (ListImagesResponse) {} // InspectImage gets the detailed image information of the specified image. rpc InspectImage (InspectImageRequest) returns (InspectImageResponse) {} // ListenEvents listens for the events, it will return a response stream // that will contain event objects. rpc ListenEvents (ListenEventsRequest) returns (stream ListenEventsResponse) {} // GetLogs gets the logs for a pod, if the app is also specified, then only the logs // of the app will be returned. // // If 'follow' in the 'GetLogsRequest' is set to 'true', then the response stream // will not be closed after the first response, the future logs will be sent via // the stream. rpc GetLogs(GetLogsRequest) returns (stream GetLogsResponse) {} } cadvisor-0.25.0/vendor/github.com/coreos/rkt/api/v1alpha/client_example.go000066400000000000000000000034241306035727200264730ustar00rootroot00000000000000// Copyright 2015 The rkt 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. // +build ignore package main import ( "fmt" "os" "github.com/coreos/rkt/api/v1alpha" "golang.org/x/net/context" "google.golang.org/grpc" ) func main() { conn, err := grpc.Dial("localhost:15441", grpc.WithInsecure()) if err != nil { fmt.Println(err) os.Exit(1) } c := v1alpha.NewPublicAPIClient(conn) defer conn.Close() // List pods. podResp, err := c.ListPods(context.Background(), &v1alpha.ListPodsRequest{ // Specify the request: Fetch and print only running pods and their details. Detail: true, Filters: []*v1alpha.PodFilter{ { States: []v1alpha.PodState{v1alpha.PodState_POD_STATE_RUNNING}, }, }, }) if err != nil { fmt.Println(err) os.Exit(2) } for _, p := range podResp.Pods { fmt.Printf("Pod %q is running\n", p.Id) } // List images. imgResp, err := c.ListImages(context.Background(), &v1alpha.ListImagesRequest{ // In this request, we fetch the details of images whose names are prefixed with "coreos.com". Detail: true, Filters: []*v1alpha.ImageFilter{ { Prefixes: []string{"coreos.com"}, }, }, }) if err != nil { fmt.Println(err) os.Exit(3) } for _, im := range imgResp.Images { fmt.Printf("Found image %q\n", im.Name) } } cadvisor-0.25.0/vendor/github.com/docker/000077500000000000000000000000001306035727200202205ustar00rootroot00000000000000cadvisor-0.25.0/vendor/github.com/eapache/000077500000000000000000000000001306035727200203375ustar00rootroot00000000000000cadvisor-0.25.0/vendor/github.com/garyburd/000077500000000000000000000000001306035727200205705ustar00rootroot00000000000000cadvisor-0.25.0/vendor/github.com/go-ini/000077500000000000000000000000001306035727200201335ustar00rootroot00000000000000cadvisor-0.25.0/vendor/github.com/godbus/000077500000000000000000000000001306035727200202345ustar00rootroot00000000000000cadvisor-0.25.0/vendor/github.com/golang/000077500000000000000000000000001306035727200202205ustar00rootroot00000000000000cadvisor-0.25.0/vendor/github.com/influxdb/000077500000000000000000000000001306035727200205645ustar00rootroot00000000000000cadvisor-0.25.0/vendor/github.com/jmespath/000077500000000000000000000000001306035727200205645ustar00rootroot00000000000000cadvisor-0.25.0/vendor/github.com/klauspost/000077500000000000000000000000001306035727200207765ustar00rootroot00000000000000cadvisor-0.25.0/vendor/github.com/kr/000077500000000000000000000000001306035727200173655ustar00rootroot00000000000000cadvisor-0.25.0/vendor/github.com/matttproud/000077500000000000000000000000001306035727200211545ustar00rootroot00000000000000cadvisor-0.25.0/vendor/github.com/opencontainers/000077500000000000000000000000001306035727200220005ustar00rootroot00000000000000cadvisor-0.25.0/vendor/github.com/pborman/000077500000000000000000000000001306035727200204075ustar00rootroot00000000000000cadvisor-0.25.0/vendor/github.com/prometheus/000077500000000000000000000000001306035727200211445ustar00rootroot00000000000000cadvisor-0.25.0/vendor/github.com/seccomp/000077500000000000000000000000001306035727200204025ustar00rootroot00000000000000cadvisor-0.25.0/vendor/github.com/stretchr/000077500000000000000000000000001306035727200206075ustar00rootroot00000000000000cadvisor-0.25.0/vendor/github.com/syndtr/000077500000000000000000000000001306035727200202745ustar00rootroot00000000000000cadvisor-0.25.0/vendor/github.com/vishvananda/000077500000000000000000000000001306035727200212535ustar00rootroot00000000000000cadvisor-0.25.0/vendor/golang.org/000077500000000000000000000000001306035727200167475ustar00rootroot00000000000000cadvisor-0.25.0/vendor/golang.org/x/000077500000000000000000000000001306035727200172165ustar00rootroot00000000000000cadvisor-0.25.0/vendor/google.golang.org/000077500000000000000000000000001306035727200202225ustar00rootroot00000000000000cadvisor-0.25.0/vendor/google.golang.org/api/000077500000000000000000000000001306035727200207735ustar00rootroot00000000000000cadvisor-0.25.0/vendor/google.golang.org/api/LICENSE000066400000000000000000000027031306035727200220020ustar00rootroot00000000000000Copyright (c) 2011 Google Inc. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of Google Inc. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. cadvisor-0.25.0/vendor/gopkg.in/000077500000000000000000000000001306035727200164265ustar00rootroot00000000000000cadvisor-0.25.0/vendor/gopkg.in/olivere/000077500000000000000000000000001306035727200200735ustar00rootroot00000000000000cadvisor-0.25.0/version/000077500000000000000000000000001306035727200151025ustar00rootroot00000000000000cadvisor-0.25.0/version/version.go000066400000000000000000000017721306035727200171250ustar00rootroot00000000000000// 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 version // Build information. Populated at build-time. var ( Version string Revision string Branch string BuildUser string BuildDate string GoVersion string ) // Info provides the iterable version information. var Info = map[string]string{ "version": Version, "revision": Revision, "branch": Branch, "buildUser": BuildUser, "buildDate": BuildDate, "goVersion": GoVersion, }