src/

The uuid package generates and inspects UUIDs.

The oauth package provides support for making OAuth2-authenticated HTTP requests.

This program makes a call to the specified API, authenticated with OAuth2.

The jwt package provides support for creating credentials for OAuth2 service account requests.

This program makes a read only call to the Google Cloud Storage API, authenticated with OAuth2.

Package compute provides access to the Compute Engine API.

Package container provides access to the Google Container Engine API.

Package googleapi contains the common code shared by all Google API libraries.

Package transport contains HTTP transports used to make authenticated API requests.

Package proto converts data structures to and from the wire format of protocol buffers.

Package api contains the latest (or "internal") version of the Kubernetes API objects.

Package errors provides detailed error types for api field validation.

Package etcd provides conversion of etcd errors to API errors.

Package latest defines the default output serializations that code should use and imports the required schemas.

Package meta provides functions for retrieving API metadata from objects belonging to the Kubernetes API

Package rest defines common logic around changes to Kubernetes resources.

Package testapi provides a helper for retrieving the KUBE_API_VERSION environment variable.

Package v1beta1 is the v1beta1 version of the API.

Package v1beta2 is the v1beta2 version of the API.

Package v1beta3 is the v1beta3 version of the API.

Package validation has functions for validating the correctness of api objects and explaining what is wrong with them when they aren't valid.

Package apiserver contains the code that provides a RESTful api service.

Package user contains utilities for dealing with simple user exchange in the auth packages.

package capbabilities manages system level capabilities

Package client contains the implementation of the client side communication with the Kubernetes master.

Package cache is a client-side caching mechanism.

Package clientcmd provides one stop shopping for building a working client from a fixed config, from a .kubeconfig file, from command line flags, or from any merged combination.

Package record has all client logic for recording and reporting events.

Package authcfg defines a file format for holding authentication information needed by clients of Kubernetes.

Package cloudprovider supplies interfaces and implementations for cloud service providers.

Package controller contains code for syncing cloud instances with minion registry

Package fake_cloud is a test-double implementation of cloudprovider Interface, TCPLoadBalancer and Instances.

Package gce_cloud is an implementation of Interface, TCPLoadBalancer and Instances for Google Compute Engine.

Package vagrant_cloud is an implementation of Interface, TCPLoadBalancer and Instances for developer managed Vagrant cluster.

Package constraint has functions for ensuring that collections of containers are allowed to run together on a single host.

Package controller contains logic for watching and synchronizing replicationControllers.

Package conversion provides go object versioning and encoding/decoding mechanisms.

Package credentialprovider supplies interfaces and implementations for docker registry providers to expose their authentication scheme.

Package gcp_credentials contains implementations of DockerConfigProvider for Google Cloud Platform.

Package healthz implements basic http server health checking.

Package httplog contains a helper object and functions to maintain a log along with an http response.

Package kubectl is a set of libraries that are used by the kubectl command line tool.

Package resource assists clients in dealing with RESTful objects that match the Kubernetes API conventions.

Package kubelet is the package that contains the libraries that drive the Kubelet binary.

Reads the pod configuration from the Kubernetes apiserver.

Package envvars is the package that build the environment variables that kubernetes provides to the containers run by it.

Package leaky holds bits of kubelet that should be internal but have leaked out through bad abstractions.

Package server makes it easy to create a kubelet server for various contexts.

Package volume includes internal representations of external volume types as well as utility methods required to mount/unmount volumes to kubelets.

Package labels implements a simple label system, parsing and matching selectors with sets of labels.

Package master contains code for setting up and running a Kubernetes cluster master.

Package ports defines ports used by various pieces of the kubernetes infrastructure.

Package server does all of the work necessary to create a Kubernetes APIServer by binding together the API, master and APIServer infrastructure.

Package probe contains utilities for health probing, as well as health status information.

Package proxy implements the layer-3 network proxy.

Package config provides decoupling between various configuration sources (etcd, files,...) and the pieces that actually care about them (loadbalancer, proxy).

Package server does all of the work necessary to configure and run a Kubernetes proxy process.

Package binding contains the middle layer logic for bindings.

Package controller provides Registry interface and it's RESTStorage implementation for storing ReplicationController api objects.

Package endpoint provides Registry interface and it's RESTStorage implementation for storing Endpoint api objects.

Package etcd provides etcd backend implementation for storing PodRegistry, ControllerRegistry and ServiceRegistry api objects.

Package event provides Registry interface and it's REST implementation for storing Event api objects.

Package generic provides a generic object store interface and a generic label/field matching type.

Package etcd has a generic implementation of a registry that stores things in etcd.

Package limitrange provides Registry interface and it's REST implementation for storing LimitRange api objects.

Package minion provides Registry interface and implementation for storing Minions.

Package namespace provides Registry interface and it's REST implementation for storing Namespace api objects.

Package pod provides Registry interface and it's RESTStorage implementation for storing Pod api objects.

Package resourcequota provides Registry interface and it's REST implementation for storing ResourceQuota api objects.

Package resourcequotausage provides Registry interface and it's REST implementation for storing ResourceQuotaUsage api objects.

Package service provides Registry interface and it's RESTStorage implementation for storing Service api objects.

resourcequota contains a controller that makes resource quota usage observations

Package runtime includes helper functions for working with API objects that follow the kubernetes API object conventions, which are:

Package scheduler contains a generic Scheduler interface and several implementations.

Package service provides EndpointController implementation to manage and sync service endpoints.

Package tools implements general tools which depend on the api package.

Package types implements various generic types used throughout kubernetes.

package ui contains static data files compiled to go, and utilities for accessing them.

Package util implements various utility functions used in both testing and implementation of Kubernetes.

Package config provides utility objects for decoupling sources of configuration and the actual configuration state.

Package errors implements various utility functions and types around errors.

Package exec provides an injectable interface and implementations for running commands.

Package iptables provides an interface and implementations for running iptables commands.

Package mount defines an interface to mounting filesystems.

Package slice provides utility methods for common operations on slices.

Package wait provides tools for polling or listening for changes to a condition.

Package version supplies version information collected at build time to kubernetes components.

Package verflag defines utility functions to handle command line flags related to version of Kubernetes.

Package watch contains a generic watchable interface, and a fake for testing code that uses the watch interface.

Package json implements a simple encoder and decoder for streams of watch events over io.Writer/Readers

Package resourcedefaults contains an example plug-in that cluster operators can use to prevent unlimited CPU and Memory usage for a container.

resourcequota enforces all incoming requests against any applied quota in the namespace context of the request

This package is used to register algorithm provider plugins.

This algorithm provider has predicates and priorities related to affinity/anti-affinity for the scheduler.

This is the default algorithm provider for the scheduler.

Package factory can set up a scheduler.

Package server implements a Server object for running the scheduler.

To test with the osin samples, change the RedirectUri to "http://localhost:14001/appauth" in osin/examples/teststorage.to

Package metrics provides both a means of generating metrics and the ability to send metric data to a graphite endpoint.

mod is the entry point to all of the etcd modules.

Extensions to the standard "os" package.

Package proto converts data structures to and from the wire format of protocol buffers.

Package journal provides write bindings to the systemd journal

Package protobuf is a generated protocol buffer package.

Package gorilla/context stores values shared during a request lifetime.

Package gorilla/mux implements a request router and dispatcher.

Provides an HTTP Transport that implements the `RoundTripper` interface and can be used as a built in replacement for the standard library's, providing:

Go port of Coda Hale's Metrics library

Metrics output to StatHat.

Package spew implements a deep pretty printer for Go data structures to aid in debugging.

Package flag implements command-line flag parsing.

Package pools provides a collection of pools which provide various data types with buffers.

assetfs allows packages to serve static content embedded with the go-bindata tool with the standard net/http package.

Package restful, a lean package for creating REST-style WebServices without magic.

Package swagger implements the structures of the Swagger https://github.com/wordnik/swagger-spec/blob/master/versions/1.2.md

Package docker provides a client for the Docker remote API.

Package testing provides a fake implementation of the Docker API, useful for testing purpose.

Package raven implements a client for the Sentry error logging service.

Package glog implements logging analogous to the Google-internal C++ INFO/ERROR/V setup.

Package proto converts data structures to and from the wire format of protocol buffers.

TODO(cAdvisor): Package comment.

Package fuzz is a library for populating go objects with random values.

Package gorilla/context stores values shared during a request lifetime.

Package gorilla/mux implements a request router and dispatcher.

Package gorilla/securecookie encodes and decodes authenticated and optionally encrypted cookie values.

Package gorilla/sessions provides cookie and filesystem sessions and infrastructure for custom session backends.

Package mergo merges same-type structs and maps by setting default values in zero-value fields.

bindata converts any file into managable Go source code.

Package ext enables record length-delimited Protocol Buffer streaming.

Provides types used for processing sti requests.

Package profile provides a simple way to manage runtime/pprof profiling of your Go application.

HTTP Content-Type Autonegotiation.

Package quantile computes approximate quantiles over an unbounded data stream within low memory and CPU bounds.

Package model contains core representation of Prometheus client primitives.

Package prometheus provides embeddable metric primitives for servers and standardized exposition of telemetry through a web services interface.

Package text contains helper functions to parse and create text-based exchange formats.

Package io_prometheus_client is a generated protocol buffer package.

Package procfs provides functions to retrieve system, kernel and process metrics from the pseudo-filesystem proc.

Package cobra is a commander providing a simple interface to create powerful modern CLI interfaces.

pflag is a drop-in replacement for Go's flag package, implementing POSIX/GNU-style --flags.

Package context defines the Context type, which carries deadlines, cancelation signals, and other request-scoped values across API boundaries and between processes.

Package html implements an HTML5-compliant tokenizer and parser.

Package atom provides integer codes (also known as atoms) for a fixed set of frequently occurring HTML strings: tag names and attribute keys such as "p" and "id".

Package charset provides common text encodings for HTML documents.

Package websocket implements a client and server for the WebSocket protocol as specified in RFC 6455.

Package oauth2 provides support for making OAuth2 authorized and authenticated HTTP requests.

Package github provides constants for using OAuth2 to access Github.

Package google provides support for making OAuth2 authorized and authenticated HTTP requests to Google APIs.

Package jws provides encoding and decoding utilities for signed JWS messages.

Package jwt implements the OAuth 2.0 JSON Web Token flow, commonly known as "two-legged OAuth 2.0".

Package appengine provides basic functionality for Google App Engine.

Package channel implements the server side of App Engine's Channel API.

Package datastore provides a client for App Engine's datastore service.

Package delay provides a way to execute code outside the scope of a user request by using the taskqueue API.

Package file provides helper functions for using Google Cloud Storage.

Package image provides image services.

Package log provides the means of querying an application's logs from within an App Engine application.

Package mail provides the means of sending email from an App Engine application.

Package memcache provides a client for App Engine's distributed in-memory key-value store for small chunks of arbitrary data.

Package module provides functions for interacting with modules.

Package remote_api implements the /_ah/remote_api endpoint.

Package search provides a client for App Engine's search service.

Package taskqueue provides a client for App Engine's taskqueue service.

Package urlfetch provides an http.RoundTripper implementation for fetching URLs via App Engine's urlfetch service.

Package user provides a client for App Engine's user authentication service.

Package xmpp provides the means to send and receive instant messages to and from users of XMPP-compatible services.

Package metadata provides access to Google Compute Engine (GCE) metadata and API service accounts.

Package yaml implements YAML support for the Go language.

Package inf (type inf.Dec) implements "infinite-precision" decimal arithmetic.