luci-go: LUCI services and tools in Go



LUCI Go code is meant to be worked on from an Chromium infra.git checkout, which enforces packages versions and Go toolchain version. First get fetch via depot_tools.git then run:

fetch infra
cd infra/go
eval `./`
cd src/


Contributing uses the same flow as Chromium contributions.

Expand ▾ Collapse ▴


Path Synopsis
appengine/bqlog Package bqlog provides a mechanism to asynchronously log rows to BigQuery.
appengine/bqlog/gae-test/gae-test Binary gae-test implements a sloppy sample app that tests 'bqlog' on GAE.
appengine/gaeauth/client Package client implements OAuth2 authentication for outbound connections from Appengine using the application services account.
appengine/gaeauth/server Package server implements authentication for inbound HTTP requests on GAE.
appengine/gaeauth/server/gaesigner Package gaesigner implements signing.Signer interface using GAE App Identity API.
appengine/gaeauth/server/internal/authdbimpl Package authdbimpl implements datastore-based storage and update of AuthDB snapshots used for authorization decisions by server/auth/*.
appengine/gaemiddleware Package gaemiddleware provides a standard middleware for Appengine apps.
appengine/gaemiddleware/flex Package flex exposes gaemiddleware Environments for AppEngine's Flex environment.
appengine/gaemiddleware/standard Package standard exposes a gaemiddleware Environment for Classic AppEngine.
appengine/gaesecrets Package gaesecrets implements storage of secret blobs on top of datastore.
appengine/gaesettings Package gaesettings implements settings.Storage interface on top of GAE datastore.
appengine/mapper Package mapper implements a simple Datastore mapper.
appengine/mapper/demo Binary demo contains minimal demo for 'mapper' package.
appengine/mapper/internal/tasks Package tasks contains definition of task queue tasks used by the mapper.
appengine/mapper/splitter Package splitter implements SplitIntoRanges function useful when splitting large datastore queries into a bunch of smaller queries with approximately evenly-sized result sets.
appengine/memlock Package memlock allows multiple appengine handlers to coordinate best-effort mutual execution via memcache.
appengine/meta Package meta contains some methods for interacting with GAE's metadata APIs.
appengine/tq Package tq implements simple routing layer for task queue tasks.
appengine/tq/tqtesting Package tqtesting can be used in unit tests to simulate task queue calls produced by tq.Dispatcher.
appengine/tsmon Package tsmon adapts common/tsmon library to GAE environment.
auth Package auth implements a wrapper around
auth/authctx Package authctx allows to run subprocesses in an environment with ambient auth.
auth/client/authcli Package authcli implements authentication related flags parsing and CLI subcommands.
auth/client/cmd/luci-auth Command luci-auth can be used to interact with OAuth2 token cache on disk.
auth/client/cmd/realms-dump Command realms-dump can dump realm configs served by an Auth Service.
auth/identity Package identity defines Identity type and related types and constants.
auth/integration/authtest Package authtest implements authentication related test helpers.
auth/integration/devshell Package devshell implements Devshell protocol for locally getting auth token.
auth/integration/firebase Package firebase implements an auth server that allows firebase-tools to use an exposed OAuth2 TokenSource for auth.
auth/integration/gcemeta Package gcemeta implements a subset of GCE metadata server protocol.
auth/integration/gsutil Package gsutil implements a hacky shim that makes gsutil use LUCI local auth.
auth/integration/internal/localsrv Package localsrv provides helpers for running local TCP servers.
auth/integration/localauth Package localauth implements localhost HTTP server that hands out tokens to local LUCI-aware processes.
auth/internal Package internal contains code used internally by auth/integration.
buildbucket Package buildbucket is a client library for Buildbucket service.
buildbucket/access Package access is DEPRECATED.
buildbucket/appengine/frontend Package main is the main entry point for the app.
buildbucket/appengine/internal/buildid Package buildid provides the build id computation related functions.
buildbucket/appengine/internal/perm Package perm implements permission checks.
buildbucket/appengine/model Package model contains datastore model implementation.
buildbucket/appengine/rpc Package rpc contains rpc service implementation.
buildbucket/appengine/tasks Package tasks contains task queue implementations.
buildbucket/appengine/tasks/defs Package taskdefs contains task queue task definitions.
buildbucket/cli Package cli implements CLI client for buildbucket service.
buildbucket/cmd/bbagent Command bbagent is Buildbucket's agent running in swarming.
buildbucket/deprecated Package deprecated is deprecated part of the buildbucket library.
buildbucket/proto Package buildbucketpb is generated from Buildbucket .proto files.
buildbucket/protoutil Package protoutil provides utility functions for protobuf messages in ../proto package.
cipd/api/admin/v1 Package api contains CIPD backend API definitions.
cipd/api/cipd/v1 Package api contains CIPD backend API definitions.
cipd/api/config/v1 Package api contains CIPD backend API definitions.
cipd/appengine/backend Binary backend implements HTTP server that handles task queues and crons.
cipd/appengine/frontend Binary frontend implements HTTP server that handles requests to 'default' module.
cipd/appengine/impl Package impl instantiates the full implementation of the CIPD backend services.
cipd/appengine/impl/admin Package admin contains implementation of cipd.Admin RPC service.
cipd/appengine/impl/cas Package cas contains implementation of cipd.Storage service RPC service.
cipd/appengine/impl/cas/tasks Package tasks contains task queue tasks definitions.
cipd/appengine/impl/gs Package gs implement Google Storage API wrapper used by CIPD backend.
cipd/appengine/impl/metadata Package metadata implements handling of prefix metadata.
cipd/appengine/impl/model Package model contains core CIPD datastore entities.
cipd/appengine/impl/monitoring Package monitoring implements monitoring used by CIPD backend.
cipd/appengine/impl/repo Package repo contains implementation of cipd.Repository service RPC service.
cipd/appengine/impl/repo/processing Package processing contains code related to post-registration instance processing.
cipd/appengine/impl/repo/tasks Package tasks contains task queue tasks definitions.
cipd/appengine/impl/settings Package settings contains definition of global CIPD backend settings.
cipd/appengine/impl/testutil Package testutil contains helpers used from CIPD backend unit tests.
cipd/appengine/ui Package ui implements request handlers that serve user facing HTML pages.
cipd/client/cipd Package cipd implements client side of Chrome Infra Package Deployer.
cipd/client/cipd/builder Package builder holds functionality for building CIPD packages.
cipd/client/cipd/deployer Package deployer holds functionality for deploying CIPD packages.
cipd/client/cipd/digests Package digests holds types used by selfupdate mechanism to pin client hashes.
cipd/client/cipd/ensure Package ensure contains methods and types for interacting with the 'ensure file format'.
cipd/client/cipd/fs Package fs is file-system related utilities used internally by CIPD.
cipd/client/cipd/internal/retry Package retry contains helpers for doing tight retry loops.
cipd/client/cipd/pkg Package pkg contains interfaces and struct related to CIPD package files.
cipd/client/cipd/platform Package platform contains definition of what ${os} and ${arch} mean for the current platform.
cipd/client/cipd/reader Package reader implements reading contents of a CIPD package.
cipd/client/cipd/template Package template implements handling of package name templates.
cipd/client/cli Package cli implements command line interface for CIPD client.
cipd/client/cmd/cipd Package main contains CIPD CLI implementation that uses Chrome Infrastructure defaults.
cipd/version Package version provides a way for CIPD packaged Go binaries to discover their current package instance ID.
client/archiver Package archiver implements the pipeline to efficiently archive file sets to an isolated server as fast as possible.
client/cmd/cas Package main is a CAS client.
client/cmd/docker-credential-luci Command docker-credential-luci is a Docker credential helper.
client/cmd/git-credential-luci Command git-credential-luci is a Git credential helper.
client/cmd/isolate Package main is a .isolate compiler that compiles .isolate files into .isolated files and can also act as a client to an Isolate server.
client/cmd/isolate/lib Package lib is used to implement the parent package main.
client/cmd/isolated Package main is an Isolate server client.
client/cmd/isolated/lib Package lib is used to implement the parent package main.
client/cmd/swarming Package main is a client to a Swarming server.
client/cmd/swarming/lib Package lib is used to implement the parent package main.
client/downloader Package downloader implements the pipeline to download file sets from an isolated server.
client/flagpb Package flagpb defines a flag format for protobuf messages, implements a parser and a formatter.
client/internal/common Package common implements code and utilities shared across all packages in client/.
client/internal/progress Package progress implements a progress indicator for text mode applications.
client/isolate Package isolate implements the code to process '.isolate' files to generate '.isolated' files.
client/versioncli Package versioncli implements a subcommand for obtaining version with the CLI.
common/api/buildbucket/buildbucket/v1 Package buildbucket provides access to the Build Bucket Service.
common/api/buildbucket/swarmbucket/v1 Package swarmbucket provides access to the Buildbucket-Swarming integration.
common/api/gitiles Package gitiles implements GitilesClient in "" package on top of Gitiles's REST API.
common/api/internal/gensupport Package gensupport is an internal implementation detail used by code generated by the google-api-go-generator tool.
common/api/isolate/isolateservice/v1 Package isolateservice provides access to the .
common/api/luci_config/config/v1 Package config provides access to the Configuration Service.
common/api/swarming/swarming/v1 Package swarming provides access to the .
common/bq Package bq is a library for working with BigQuery.
common/cli Package cli is a helper package for "".
common/clock Package clock is an interface to system time and timers which is easy to test.
common/data/base128 Package base128 implements base128 encoding and decoding.
common/data/caching/cache Package cache implements both in-memory and on-disk caching.
common/data/caching/cacheContext Package cacheContext implements a context.Context wrapper which caches the results of Value calls, speeding up subsequent calls for the same key.
common/data/caching/lazyslot Package lazyslot implements a caching scheme for globally shared objects that take significant time to refresh.
common/data/caching/lru Package lru provides least-recently-used (LRU) cache.
common/data/cmpbin Package cmpbin provides binary serialization routines which ensure that the serialized objects maintain the same sort order of the original inputs when sorted bytewise (i.e.
common/data/rand/cryptorand Package cryptorand implements a mockable source or crypto strong randomness.
common/data/rand/mathrand Package mathrand implements a mockable interface for math/rand.Rand.
common/data/recordio Package recordio implements a basic RecordIO reader and writer.
common/data/sortby Package sortby provides a succinct way to generate correctly-behaved Less functions for use with the stdlib 'sort' package.
common/data/stringset Package stringset is an exceedingly simple 'set' implementation for strings.
common/data/strpair Package strpair implements parsing and formatting of lists of colon-delimited key-value pair strings.
common/data/text/pattern Package pattern implements lightweight parsable string patterns.
common/data/text/sanitizehtml Package sanitizehtml implements a sanitizer of a very limited HTML.
common/data/text/stringtemplate Package stringtemplate implements Python string.Template-like substitution.
common/data/text/templateproto Package templateproto defines a proto-based way to configure templates for JSON documents.
common/data/text/units Package units provides common useful printable units.
common/data/treapstore Package treapstore is a lightweight append-only in-memory key-value store built on top a treap (tree + heap) implementation.
common/errors Package errors is an augmented replacement package for the stdlib "errors" package.
common/flag Package flag provides the utilities for implementing command line flags.
common/flag/flagenum Package flagenum is a utility package which facilitates implementation of flag.Value, json.Marshaler, and json.Unmarshaler interfaces via a string-to- value mapping.
common/flag/multiflag Package multiflag is a package providing a flag.Value implementation capable of switching between multiple registered sub-flags, each of which have their own set of parameter flags.
common/flag/stringlistflag Package stringlistflag provides a flag.Value implementation which resolves multiple args into a []string.
common/flag/stringmapflag Package stringmapflag provides a flag.Value that, when parsed, augments a map[string]string with the supplied parameter.
common/flag/stringsetflag Package stringsetflag provides a flag.Value implementation which resolves multiple args into a stringset.
common/gcloud/gae Package gae defines information about the AppEngine environment.
common/gcloud/googleoauth Package googleoauth contains some helpers related to Google OAuth2.
common/gcloud/gs Package gs implements a versatile Google Storage client on top of the standard Google Storage Go API.
common/gcloud/iam Package iam implements wrappers around some Google Cloud IAM APIs.
common/git/footer Package footer implements parsing logic for git footer and its predecessor (legacy `<KEY>=<arbitrary value>` style).
common/iotools Package iotools contains a collection of I/O-related utility structs and methods.
common/isolated Package isolated defines the isolated common code shared by the client and server.
common/isolatedclient Package isolatedclient implements the API to communicate with the Isolated server and to process '.isolated' files.
common/isolatedclient/isolatedfake Package isolatedfake implements an in-process fake Isolated server for integration testing.
common/lhttp Package lhttp implements HTTP client helper code (JSON, automatic retries, authentication, etc).
common/logging Package logging defines Logger interface and context.Context helpers to put\get logger from context.Context.
common/logging/gologger Package gologger is a compatibility layer between go-logging library and luci-go/common/logging.
common/logging/sdlogger Package sdlogger is a logger that formats entries as JSON understood by Stackdriver log collectors.
common/proto Package proto contains protobuf-related utilities.
common/proto/access Package access contains Access service protocol.
common/proto/config Package config contains luci-config protobuf definitions.
common/proto/examples Package examples shows how to design protos which adhere to the Google Cloud API design guide.
common/proto/gerrit Package gerrit contains Gerrit service definition.
common/proto/git Package git contains Git-related protobuf definitions.
common/proto/gitiles Package gitiles contains Gitiles service definition.
common/proto/google Package google contains utility methods to help interface between Google standard protobufs and native Go types.
common/proto/google/descutil Package descutil contains utility functions for protobuf descriptor messages.
common/proto/mask Package mask provides utility functions for google protobuf field mask Supports advanced field mask semantics: - Refer to fields and map keys using .
common/proto/paged Package paged implements a helper for making paginated Datastore queries.
common/proto/realms Package realms contains LUCI Realms protobuf definitions.
common/proto/srcman Package srcman contains source manifest protobuf definitions.
common/retry/transient Package transient allows you to tag and retry 'transient' errors (i.e.
common/runtime/goroutine Package goroutine is mostly to house a function for obtaining the current goroutine ID, but probably will eventually contain other naughty functions.
common/runtime/paniccatcher Package paniccatcher package exposes a set of utility structures and methods that support standardized panic catching and handling.
common/runtime/profiling Package profiling provides a tool to profile various aspects of the process.
common/spantest Package spantest implements creation/destruction of a temporary Spanner database.
common/sync/dispatcher Package dispatcher implements a super-charged version of a buffered channel connected to a (potentially) parallelized work dispatcher.
common/sync/dispatcher/buffer Package buffer implements a batching buffer with batch lease and retry management.
common/sync/mutexpool Package mutexpool implements P, a pool of keyed mutexes.
common/system/environ Package environ is an environment variable manipulation library.
common/system/exec2 Package exec2 is like os/exec but supports timeout in Wait and process containment for unix using process group.
common/system/exitcode Package exitcode provides common methods to extract exit codes from errors returned by exec.Cmd.
common/system/pager Package pager implements paging using commands "less" or "more", depending on availability.
common/system/prober Package prober exports Probe, which implements logic to identify a wrapper's wrapped target.
common/system/signals Package signals makes it easier to catch SIGTERM.
common/system/terminal Package terminal is just a way to forward "".IsTerminal(fd int) In a way that will work on appengine (specifically; it doesn't break appengine's compilation).
common/testing/assertions Package assertions is designed to be a collection of `.` importable, goconvey compatible testing assertions, in the style of "".
common/testing/mock Package mock has utility functions for gomock.
common/testing/prpctest Package prpctest is a package to facilitate pRPC testing by wrapping httptest with a pRPC Server.
common/trace Package trace provides support for collecting tracing spans.
common/tsmon Package tsmon contains global state and utility functions for configuring and interacting with tsmon.
common/tsmon/distribution Package distribution contains distribution metrics, fixed width and geometric bucketers.
common/tsmon/examples/beep package dummy_project implements a demo application that populates monitoring data for a dummy_project.
common/tsmon/examples/beep/dummy_project dummy_project implements a monitoring target interface for DummyProject.
common/tsmon/field Package field contains constructors for metric field definitions.
common/tsmon/metric Package metric is the API for defining metrics and updating their values.
common/tsmon/monitor Package monitor contains the code for sending metric data to monitoring endpoints.
common/tsmon/registry Package registry holds a map of all metrics registered by the process.
common/tsmon/runtimestats Package runtimestats exposes metrics related to the Go runtime.
common/tsmon/store Package store contains code for storing and retrieving metrics.
common/tsmon/store/storetest Package storetest is imported exclusively by tests for Store implementations.
common/tsmon/target Package target contains information about the thing that is sending metrics - either a NetworkDevice (a machine) or a Task (a service).
common/tsmon/ts_mon_proto Package ts_mon_proto contains ts_mon protobuf source and generated protobuf data.
common/tsmon/types Package types contains miscellaneous structs and interfaces used throughout tsmon.
common/tsmon/versions Package versions allows processes to report string-valued metrics with versions of various libraries they link with.
config Package config contains a client to access LUCI configuration service.
config/appengine/gaeconfig Package gaeconfig implements LUCI-config service bindings backed by AppEngine storage and caching.
config/cfgclient Package cfgclient contains glue code to use config.Interface client.
config/impl/erroring Package erroring implements a backend that always returns an error for all of its calls.
config/impl/filesystem Package filesystem implements a file system backend for the config client.
config/impl/memory Package memory implements in-memory backend for the config client.
config/impl/resolving Package resolving implements an interface that resolves ${var} placeholders in config set names and file paths before forwarding calls to some other interface.
config/server/cfgcache Package cfgcache provides a datastore-based cache of individual config files.
config/server/cfgmodule Package cfgmodule provides a server module with a LUCI Config client.
config/validation Package validation provides helpers for performing and setting up handlers for config validation related requests from luci-config.
config/vars Package vars implements a registry of ${var} placeholders.
cq/appengine/config Package config implements validation and common manipulation of CQ config files.
cq/appengine/frontend Binary frontend is the main entry point for the CQ app.
cv/api/config/v2 Package config contains the CQ config schema.
cv/api/recipe/v1 Package recipe contains CQ Recipe input proto.
cv/internal/gerrit/botdata Package botdata implements parsing and generation logic for BotData.
cv/internal/gerrit/gobmap Package gobmap finds relevant LUCI project config given a Gerrit CL.
cv/internal/submission Package submission contains all related logic to submit Gerrit CLs.
dm Package dm is the service and tooling for the Dungeon Master (DM) distributed dependency scheduling service.
dm/appengine Package appengine provides the appengine service implementation for DM.
dm/appengine/deps Package deps implements DM's Deps RPC methods.
dm/appengine/distributor Package distributor contains all the adaptors for the various supported distributor protocols.
dm/appengine/frontend Binary frontend is DM's Google AppEngine application stub.
dm/appengine/model Package model contains all of DM's datastore models.
dm/appengine/mutate Package mutate includes the main logic of DM's state machine.
dm/tools/jobsim_client Jobsim client is a self-contained binary that implements various toy job algorithms for use in testing DM with live distributors (like swarming).
examples/appengine/helloworld_standard/frontend Package main implements HTTP server that handles requests to default module.
examples/appengine/tq Demo of server/tq module on Appengine.
gae Package gae provides a fakable wrapped interface for the appengine SDK's APIs.
gae/filter/count Package count contains 'counter' filters for all the gae services.
gae/filter/dscache Package dscache provides a transparent cache for RawDatastore which is backed by Memcache.
gae/filter/featureBreaker Package featureBreaker contains filters for dynamically disabling/breaking API features at test-time.
gae/filter/featureBreaker/flaky Package flaky can be used to emulate flaky GAE errors that happen randomly with some probability.
gae/filter/readonly Package readonly implements a filter that enforces read-only accesses to services.
gae/filter/txnBuf Package txnBuf contains a transaction buffer filter for the datastore service.
gae/filter/txndefer Package txndefer implements a filter that calls best-effort callbacks on successful transaction commits.
gae/impl/cloud Package cloud provides an implementation of services based on regular Cloud APIs and works from anywhere (not necessarily from AppEngine).
gae/impl/dummy Package dummy provides panicking dummy implementations of all service Interfaces.
gae/impl/memory Package memory provides an implementation of infra/gae/libs/wrapper which backs to local memory ONLY.
gae/impl/prod Package prod provides an implementation of services/* which backs to AppEngine Classic (Go version <=1.11).
gae/impl/prod/constraints Package constraints contains production datastore constraints.
gae/service/blobstore Package blobstore is a PLACEHOLDER for the blobstore implementation.
gae/service/datastore/dumper Package dumper implements a very VERY dumb datastore-dumping debugging aid.
gae/service/datastore/internal/protos/datastore Package datastore is a generated protocol buffer package.
gae/service/datastore/meta Package meta contains some methods for interacting with GAE's metadata APIs.
gae/service/info/support Package support provides Info-related support functionality.
gae/service/logging Package logging is simply documentation :) In order to use logging, please import and use the "" package.
gae/service/urlfetch Package urlfetch provides a way for an application to get http.RoundTripper that can make outbound HTTP requests.
gce/api/config/v1 Package config contains VM config definitions.
gce/api/instances/v1 Package instances contains a GCE instances service.
gce/api/projects/v1 Package projects contains GCP project config definitions.
gce/api/tasks/v1 Package tasks contains task queue task definitions.
gce/appengine/backend Package backend includes cron and task queue handlers.
gce/appengine/backend/internal/metrics Package metrics includes tsmon metric support.
gce/appengine/config Package config knows how import configs from LUCI-config.
gce/appengine/frontend Package main is the main entry point for the app.
gce/appengine/model Package model contains datastore model definitions.
gce/appengine/rpc Package rpc contains RPC server implementations.
gce/appengine/rpc/memory Package memory contains a RPC servers backed by in-memory storage.
gce/appengine/testing/roundtripper Package roundtripper contains http.RoundTripper implementations suitable for testing.
gce/cmd/agent Package main is generated by
gce/vmtoken Package vmtoken implements parsing and verification of signed GCE VM metadata tokens.
gce/vmtoken/client Package client implements client-side fetch and transmission of signed GCE VM metadata tokens.
grpc/appstatus Package appstatus can attach/reterieve an application-specific response status to/from an error.
grpc/cmd/prpc Command prpc can make RPCs to pRPC servers and display their description.
grpc/cmd/svcdec Command svcdec stands for 'service decorator'.
grpc/cmd/svcmux Command svcmux reads a service interface XYZServer generated by protoc and generates VersionedXYZV struct that stores a map version->implementation, and a default version.
grpc/discovery Package discovery implements RPC service introspection.
grpc/grpcmon Package grpcmon defines gRPC interceptors with monitoring instrumentation.
grpc/grpcutil Package grpcutil is a utility package to supplement Google's gRPC package, "".
grpc/internal/svctool Package svctool implements svcmux/svcdec tools command line parsing
grpc/logging Package logging implements a gRPC glog.Logger implementation backed by a Logger.
grpc/prpc Package prpc (provisional RPC) implements an RPC client over HTTP 1.x.
grpc/svcmux Package svcmux contains utility functions used by code generated by svcmux tool.
hardcoded/chromeinfra Package chromeinfra contains hardcoded values related to Chrome Infra.
led Command led implements a 'led' binary WITHOUT support for "kitchen" based tasks.
led/ledcli Package ledcli implements the subcommands for the `led` command line tool.
led/ledcmd Package ledcmd implements the subcommands for the `led` command line tool which interact with external services.
logdog/api/config/svcconfig Package svcconfig stores service configuration for a LogDog instance.
logdog/api/endpoints/coordinator/logs/v1 Package logdog contains Version 1 of the LogDog Coordinator user interface.
logdog/api/endpoints/coordinator/registration/v1 Package logdog contains Version 1 of the LogDog Coordinator stream registration interface.
logdog/api/endpoints/coordinator/services/v1 Package logdog contains Version 1 of the LogDog Coordinator backend service interface.
logdog/api/logpb Package logpb contains LogDog protobuf source and generated protobuf data.
logdog/appengine/cmd/coordinator/default Binary default is a simple AppEngine LUCI service.
logdog/appengine/cmd/coordinator/logs Package main is the main entry point for the `vmuser` LogDog AppEngine executable.
logdog/appengine/cmd/coordinator/services Binary services is the main entry point for the `services` LogDog AppEngine executable.
logdog/appengine/cmd/coordinator/static Binary stub doesn't actually do anything.
logdog/client/bootstrapResult Package bootstrapResult defines a common way to express the result of bootstrapping a command via JSON.
logdog/client/butler Package butler is the main engine for the Butler executable.
logdog/client/butler/bootstrap Package bootstrap handles Butler-side bootstrapping functionality.
logdog/client/butler/bundler Package bundler is responsible for efficiently transforming aggregate stream data into Butler messages for export.
logdog/client/butler/output Package output contains interfaces and implementations for Butler Outputs, which are responsible for delivering Butler protobufs to LogDog collection endpoints.
logdog/client/butler/output/log Package log implements the "log" Output.
logdog/client/butler/output/logdog Package logdog implements output to a Logdog server via PubSub.
logdog/client/butlerlib/streamproto Package streamproto describes the protocol primitives used by LogDog/Butler for stream negotiation.
logdog/client/cmd/logdog_butler Package main is entry point for the command-line LogDog Butler application.
logdog/client/pubsubprotocol Package pubsubprotocol implements the LogDog pubsub wire protocol.
logdog/common/archive Package archive constructs a LogDog archive out of log stream components.
logdog/common/renderer Package renderer exports the capability to render a LogDog log stream to an io.Writer.
logdog/common/storage/archive Package archive implements a storage.Storage instance that retrieves logs from a Google Storage archive.
logdog/common/storage/archive/logdog_archive_test Package main implements a simple CLI tool to load and interact with Google Storage archived data.
logdog/common/storage/bigtable Package bigtable provides an implementation of the Storage interface backed by Google Cloud Platform's BigTable.
logdog/common/storage/bigtable/logdog_bigtable_test Package main implements a simple CLI tool to load and interact with storage data in Google BigTable data.
logdog/common/storage/memory Package memory implements in-memory Storage structures.
logdog/common/viewer Package viewer is a support library to interact with the LogDog web app and log stream viewer.
logdog/server/collector Package collector implements the LogDog Collector daemon's log parsing and registration logic.
logdog/server/collector/coordinator Package coordinator implements a minimal interface to the Coordinator service that is sufficient for Collector usage.
logdog/server/config Package config abstracts access to Logdog service and project configuration.
luci_notify/cmd/preview_email Command preview_email renders an email template file.
luci_notify/mailtmpl Package mailtmpl implements email template bundling and execution.
luci_notify/notify Define the constants to use in notify
lucicfg Package lucicfg contains LUCI config generator.
lucicfg/buildifier Package buildifier implements processing of Starlark files via buildifier.
lucicfg/cli Package cli contains command line interface for lucicfg tool.
lucicfg/cli/base Package base contains code shared by other CLI subpackages.
lucicfg/cli/cmds/diff Package diff implements 'semantic-diff' subcommand.
lucicfg/cli/cmds/fmt Package fmt implements 'fmt' subcommand.
lucicfg/cli/cmds/generate Package generate implements 'generate' subcommand.
lucicfg/cli/cmds/lint Package lint implements 'lint' subcommand.
lucicfg/cli/cmds/validate Package validate implements 'validate' subcommand.
lucicfg/cmd/docgen Command docgen is the documentation generator.
lucicfg/cmd/lucicfg Command lucicfg is CLI for LUCI config generator.
lucicfg/doc Package doc generates starlark documentation.
lucicfg/docgen Package docgen generates documentation from Starlark code.
lucicfg/docgen/ast Package ast defines AST relevant for the documentation generation.
lucicfg/docgen/docstring Package docstring parses docstrings into more structured representation.
lucicfg/docgen/symbols Package symbols defines a data model representing Starlark symbols.
lucicfg/graph Package graph implements a DAG used internally to represent config objects.
lucicfg/normalize Package normalize contains functions to "flatten" and normalize LUCI configs.
lucicfg/starlark Package starlark is generated by
lucicfg/vars Package vars implement lucicfg.var() support.
lucictx Package lucictx implements a Go client for the protocol defined here: It differs from the python client in a couple ways: * The initial LUCI_CONTEXT value is captured once at application start.
luciexe Package luciexe documents the "LUCI Executable" protocol, and contains constants which are part of this protocol.
luciexe/exe Package exe implements a client for the LUCI Executable ("luciexe") protocol.
luciexe/host Package host implements the 'Host Application' portion of the luciexe protocol.
luciexe/host/buildmerge Package buildmerge implements the build.proto tracking and merging logic for luciexe host applications.
luciexe/invoke Package invoke implements the process of invoking a 'luciexe' compatible subprocess, but without setting up any of the 'host' requirements (like a Logdog Butler or LUCI Auth).
luciexe/legacy Package legacy holds libraries and tools for @@@annotation@@@ protocol which is the predecessor of luciexe protocol.
luciexe/legacy/annotee/annotation Package annotation implements a state machine that constructs Milo annotation protobufs from a series of annotation commands.
luciexe/legacy/annotee/executor Package executor contains an implementation of the Annotee Executor.
luciexe/legacy/annotee/proto Package annopb contains protobuf definitions for legacy annotation.
luciexe/legacy/cmd/run_annotations Command run_annotations is a LUCI executable that wraps a command that produces @@@ANNOTATIONS@@@, and converts annotations to build message.
machine-db/appengine/frontend Package main contains the Machine Database AppEngine front end.
machine-db/appengine/ui Package ui contains Machine Database web UI.
machine-db/client/cli Package cli contains the Machine Database command-line client.
machine-db/client/cmd/crimson Package main contains the Machine Database CLI implementation.
machine-db/common Package common contains common Machine Database functions.
milo/git Package git provides high level API for Git/Gerrit data.
milo/git/gitacls Package gitacls implements read ACLs for Git/Gerrit data.
mp/cmd/snapshot Package main contains a tool which takes a snapshot of the given disk.
resultdb/cmd/taskwatcher Command taskwatcher polls swarming tasks, calls luci.resultdb.rpc.v1.Deriver.DeriveChromiumInvocation and logs results.
resultdb/internal/artifactcontent Package artifactcontent can serve artifact content via plain HTTP securely.
resultdb/internal/cron Package cron can runs functions periodically.
resultdb/internal/services/deriver Package deriver implements a binary that hosts luci.resultdb.v1.Deriver service.
resultdb/internal/services/globalmetrics Package globalmetrics reports metrics that are computationally heavy.
resultdb/internal/services/purger Package purger deletes expired test results from Spanner.
resultdb/internal/services/recorder Package recorder implements a binary that hosts luci.resultdb.v1.Recorder service.
resultdb/internal/spanutil Package span contains utility functions to interact with the underlying Spanner storage.
resultdb/internal/tasks Package tasks implements asynchronous invocation processing.
resultdb/internal/testutil/insert Package insert implements functions to insert rows for testing purposes.
resultdb/pbutil Package pbutil implements utility functions for ResultDB protobuf messages.
resultdb/sink Package sink provides a server for aggregating test results and sending them to the ResultDB backend.
rts/presubmit/eval Package eval estimates safety and precision of a given RTS algorithm.
scheduler/api/scheduler/v1 Package scheduler contains the main API of Scheduler service.
scheduler/appengine/acl Package acl implements ACLs for enforcement in API and UI.
scheduler/appengine/apiservers Package apiservers implements gRPC APIs exposed by Scheduler service.
scheduler/appengine/catalog Package catalog implements a part that talks to luci-config service to fetch and parse job definitions.
scheduler/appengine/engine Package engine implements the core logic of the scheduler service.
scheduler/appengine/engine/dsset Package dsset implements a particular flavor of datastore-backed set.
scheduler/appengine/engine/policy Package policy contains implementation of triggering policy functions.
scheduler/appengine/frontend Binary frontend implements GAE web server for luci-scheduler service.
scheduler/appengine/internal Package internal contains internal structs used by the tasks and the engine.
scheduler/appengine/presentation Package presentation implements common method to API and UI serving.
scheduler/appengine/task Package task defines interface between Scheduler engine and implementations of particular tasks (such as URL fetch tasks, Swarming tasks, DM tasks, etc).
scheduler/appengine/task/buildbucket Package buildbucket implements tasks that run Buildbucket jobs.
scheduler/appengine/task/noop Package noop implements tasks that do nothing at all.
scheduler/appengine/task/urlfetch Package urlfetch implements tasks that just make HTTP calls.
scheduler/appengine/task/utils Package utils contains a bunch of small functions used by task/ subpackages.
scheduler/appengine/ui Package ui implements request handlers that serve user facing HTML pages.
server Package server implements an environment for running LUCI servers.
server/analytics Package analytics provides a standard way to store the Google Analytics tracking ID.
server/auth Package auth implements authentication and authorization framework for HTTP servers.
server/auth/authdb Package authdb contains definition of Authentication Database (aka AuthDB).
server/auth/authdb/dump Package dump implements loading AuthDB from dumps in Google Storage.
server/auth/authdb/internal/certs Package certs knows how to fetch certificate bundles of trusted services.
server/auth/authdb/internal/globset Package globset preprocesses []identity.Glob for faster querying.
server/auth/authdb/internal/graph Package graph implements handling of the groups graph.
server/auth/authdb/internal/ipaddr Package ipaddr implements IP whitelist check.
server/auth/authdb/internal/legacy Package legacy contains older implementation of IsMember check.
server/auth/authdb/internal/oauthid Package oauthid implements OAuth client ID whitelist check.
server/auth/authdb/internal/realmset Package realmset provides queryable representation of LUCI Realms DB.
server/auth/authdb/internal/seccfg Package seccfg interprets SecurityConfig proto message.
server/auth/authtest Package authtest implements some interfaces used by auth package to simplify unit testing.
server/auth/delegation Package delegation contains low-level API for working with delegation tokens.
server/auth/iap Package iap implements auth.Method for GCP's Identity Aware Proxy.
server/auth/openid Package openid implements OpenID Connect Login protocol (client side).
server/auth/realms Package realms contains functionality related to LUCI Realms.
server/auth/service Package service implements a wrapper around API exposed by auth_service: The main focus is AuthDB replication protocol used to propagate changes to database of groups.
server/auth/signing Package signing provides interfaces to sign arbitrary small blobs with RSA-SHA256 signature (PKCS1v15) and verify such signatures.
server/auth/signing/signingtest Package signingtest implements signing.Signer interface using small random keys.
server/auth/xsrf Package xsrf provides Cross Site Request Forgery prevention middleware.
server/caching Package caching implements common server object caches.
server/caching/cachingtest Package cachingtest contains helpers for testing code that uses caching package.
server/caching/layered Package layered provides a two-layer cache for serializable objects.
server/cmd/statsd-to-tsmon Executable statsd-to-tsmon implements a statsd sink that sends aggregated metrics to tsmon.
server/cmd/tq-sweeper-spanner Executable tq-sweeper-spanner runs an inproc sweeping driver that scans Spanner database for TQ transactional tasks reminders.
server/experiments Package experiments allow servers to use experimental code paths.
server/gaeemulation Package gaeemulation provides a server module that adds implementation of some APIs to the global server context.
server/internal Package internal is supporting code used by server.go.
server/limiter Package limiter implements load shedding for servers.
server/middleware Package middleware defines base type for context-aware HTTP request handler.
server/module Package module defines a framework for extending server.Server with optional reusable bundles of functionality (called "modules", naturally).
server/portal Package portal implements HTTP routes for portal pages.
server/portal/internal/assets Package assets is generated by
server/pprof Package pprof is similar to net/http/pprof, except it supports auth.
server/redisconn Package redisconn implements integration with a Redis connection pool.
server/router Package router provides an HTTP router with support for middleware and subrouters.
server/secrets Package secrets provides an interface for a simple secret store: you ask it for a secret (a byte blob, identifies by some key), and it returns it to you (current version, as well as a bunch of previous versions).
server/secrets/testsecrets Package testsecrets provides a dumb in-memory secret store to use in unit tests.
server/settings Package settings implements storage for infrequently changing global settings.
server/span Package span implements a server module for communicating with Cloud Spanner.
server/templates Package templates implements wrapper around html/template to provide lazy loading of templates and better integration with HTTP middleware framework.
server/tokens Package tokens provides means to generate and validate base64 encoded tokens compatible with luci-py's components.auth implementation.
server/tq Package tq provides a task queue implementation on top of Cloud Tasks.
server/tq/internal/db Package db defines common database interface.
server/tq/internal/lessor Package lessor defines common lessor interface.
server/tq/internal/partition Package partition encapsulates partitioning and querying large keyspace which can't be expressed even as uint64.
server/tq/internal/reminder Package reminder holds Reminder to avoid circular dependencies.
server/tq/internal/testutil Package testutil provides fakes for testing TQ guts.
server/tq/internal/workset Package workset contains a synchronized work queue implementation used by inproc sweeper.
server/tq/tqtesting Package tqtesting contains helpers for running server/tq in tests and on localhost.
server/tq/txn/datastore Datastore contains Transactional Enqueue support for Cloud Datastore.
server/tq/txn/spanner Spanner contains Transactional Enqueue support for Cloud Spanner.
server/tsmon Package tsmon adapts common/tsmon library to a server-side environment.
server/warmup Package warmup allows to register hooks executed during the server warmup.
starlark/builtins Package builtins is a collection of potentially useful Starlark builtins.
starlark/interpreter Package interpreter contains customized Starlark interpreter.
starlark/starlarkproto Package starlarkproto exposes protobuf messages as Starlark types.
starlark/starlarktest Package starlarktest contains utilities for running Starlark tests.
starlark/typed Package typed contains implementation of strongly-typed lists and dicts.
tokenserver/api Package tokenserver contains common protobuf messages for the token server.
tokenserver/api/admin/v1 Package admin contains The Token Server Administrative and Config API.
tokenserver/api/bq Package bq contains BigQuery tables schemas.
tokenserver/api/minter/v1 Package minter contains the main API of the token server.
tokenserver/appengine/backend Binary backend implements HTTP server that handles requests to 'backend' module.
tokenserver/appengine/frontend Binary frontend implements HTTP server that handles requests to 'default' module.
tokenserver/appengine/impl/certchecker Package certchecker contains implementation of CertChecker.
tokenserver/appengine/impl/certconfig Package certconfig contains code to work with imported CAs and their CRLs.
tokenserver/appengine/impl/machinetoken Package machinetoken implements generation of LUCI machine tokens.
tokenserver/appengine/impl/serviceaccountsv2 Package serviceaccountsv2 implements MintServiceAccountToken RPC.
tokenserver/appengine/impl/services/admin/adminsrv Package adminsrv implements Admin API.
tokenserver/appengine/impl/services/admin/certauthorities Package certauthorities implements CertificateAuthorities API.
tokenserver/appengine/impl/services/minter/tokenminter Package tokenminter implements TokenMinter API.
tokenserver/appengine/impl/utils Package utils contains a variety of small utility functions used by other tokenserver packages.
tokenserver/appengine/impl/utils/identityset Package identityset implements a set-like structure for identity.Identity.
tokenserver/appengine/impl/utils/policy Package policy contains implementation of Policy parsing and querying.
tokenserver/appengine/impl/utils/revocation Package revocation contains utilities for implementing token revocation.
tokenserver/appengine/impl/utils/shards Package shards provides a low level support for implementing sharded set of []byte blobs.
tokenserver/appengine/impl/utils/tokensigning Package tokensigning implements utilities for RSA-signing of proto messages.
tokenserver/auth/machine Package machine implements authentication based on LUCI machine tokens.
tokenserver/client Package client implements pRPC client for The Token Server.
tokenserver/cmd/luci_machine_tokend Command luci_machine_tokend runs on all machines via cron.
tools/cmd/apigen Package main hosts the Cloud Endpoints API generator utility.
tools/cmd/assets Package main hosts the utility that converts binary assets into assets.gen.go file, so that they can be baked directly into the executable.
tools/cmd/bqschemaupdater Command bqschemaupdater accepts location and schema of a BigQuery table and creates or updates the table.
tools/cmd/gorun Package main defines the `gorun` tool, a shorthand tool to extend the "go run"-like convenience to packages.
tumble Package tumble is a distributed multi-stage transaction processor for appengine.
vpython Package vpython implements the vpython tool and associated libraries.
vpython/api/vpython Package vpython contains `vpython` environment definition protobufs.
vpython/venv/assets Package assets is generated by
web/gowrappers/rpcexplorer Package rpcexplorer contains complied RPCExplorer web app.
web/gowrappers/rpcexplorer/internal Package internal is generated by