luci: go.chromium.org/luci

Directories

PathSynopsis
appengine/datastorecachePackage datastorecache implements a managed versatile datastore caching.
appengine/gaeauth/clientPackage client implements OAuth2 authentication for outbound connections from Appengine using the application services account.
appengine/gaeauth/serverPackage server implements authentication for inbound HTTP requests on GAE.
appengine/gaeauth/server/gaesignerPackage gaesigner implements signing.Signer interface using GAE App Identity API.
appengine/gaeauth/server/internal/authdbimplPackage authdbimpl implements datastore-based storage and update of AuthDB snapshots used for authorization decisions by server/auth/*.
appengine/gaemiddlewarePackage gaemiddleware provides a standard middleware for Appengine apps.
appengine/gaemiddleware/flexPackage flex exposes gaemiddleware Environments for AppEngine's Flex environment.
appengine/gaemiddleware/standardPackage standard exposes a gaemiddleware Environment for Classic AppEngine.
appengine/gaesecretsPackage gaesecrets implements storage of secret blobs on top of datastore.
appengine/gaesettingsPackage gaesettings implements settings.Storage interface on top of GAE datastore.
appengine/gaetesting
appengine/memlockPackage memlock allows multiple appengine handlers to coordinate best-effort mutual execution via memcache.
appengine/metaPackage meta contains some methods for interacting with GAE's metadata APIs.
appengine/tqPackage tq implements simple routing layer for task queue tasks.
appengine/tq/tqtestingPackage tqtesting can be used in unit tests to simulate task queue calls produced by tq.Dispatcher.
appengine/tsmonPackage tsmon adapts common/tsmon library to GAE environment.
authPackage auth implements a wrapper around golang.org/x/oauth2.
auth/client/authcliPackage authcli implements authentication related flags parsing and CLI subcommands.
auth/client/cmd/luci-authCommand luci-auth can be used to interact with OAuth2 token cache on disk.
auth/client/luci_auth
auth/identityPackage identity defines Identity type and related types and constants.
auth/integration/authtestPackage authtest implements authentication related test helpers.
auth/integration/devshellPackage devshell implements Devshell protocol for locally getting auth token.
auth/integration/firebasePackage firebase implements an auth server that allows firebase-tools to use an exposed OAuth2 TokenSource for auth.
auth/integration/gsutilPackage gsutil implements a hacky shim that makes gsutil use LUCI local auth.
auth/integration/internal/localsrvPackage localsrv provides helpers for running local TCP servers.
auth/integration/localauthPackage localauth implements localhost HTTP server that hands out tokens to local LUCI-aware processes.
auth/integration/localauth/rpcs
auth/internalPackage internal contains code used internally by auth/integration.
buildbucketPackage buildbucket defines Go types that are more convenient than the API types in "go.chromium.org/luci/common/api/buildbucket/buildbucket/v1"
buildbucket/access
buildbucket/client/cmd/buildbucketCommand buildbucket is a CLI client for buildbucket service.
buildbucket/protoPackage buildbucket is generated from Buildbucket .proto files.
buildbucket/proto/config
cipd/api/cipd/v1Package api contains CIPD backend API definitions.
cipd/appengine/backendPackage backend implements HTTP server that handles task queues and crons.
cipd/appengine/frontendPackage frontend implements HTTP server that handles requests to 'default' module.
cipd/appengine/implPackage impl instantiates the full implementation of the CIPD backend services.
cipd/appengine/impl/casPackage cas contains implementation of cipd.Storage service RPC service.
cipd/appengine/impl/cas/tasksPackage tasks contains task queue tasks definitions.
cipd/appengine/impl/cas/upload
cipd/appengine/impl/gsPackage gs implement Google Storage API wrapper used by CIPD backend.
cipd/appengine/impl/metadataPackage metadata implements handling of prefix metadata.
cipd/appengine/impl/modelPackage model contains core CIPD datastore entities.
cipd/appengine/impl/repoPackage repo contains implementation of cipd.Repository service RPC service.
cipd/appengine/impl/repo/processingPackage processing contains code related to post-registration instance processing.
cipd/appengine/impl/repo/tasksPackage tasks contains task queue tasks definitions.
cipd/appengine/impl/settingsPackage settings contains definition of global CIPD backend settings.
cipd/appengine/impl/testutilPackage testutil contains helpers used from CIPD backend unit tests.
cipd/appengine/static
cipd/appengine/uiPackage ui implements request handlers that serve user facing HTML pages.
cipd/client/cipdPackage cipd implements client side of Chrome Infra Package Deployer.
cipd/client/cipd/digestsPackage digests holds types used by selfupdate mechanism to pin client hashes.
cipd/client/cipd/ensurePackage ensure contains methods and types for interacting with the 'ensure file format'.
cipd/client/cipd/internal
cipd/client/cipd/internal/messages
cipd/client/cipd/local
cipd/client/cipd/platformPackage platform contains definition of what ${os} and ${arch} mean for the current platform.
cipd/client/cipd/templatePackage template implements handling of package name templates.
cipd/client/cliPackage cli implements command line interface for CIPD client.
cipd/client/cmd/cipdPackage main contains CIPD CLI implementation that uses Chrome Infrastructure defaults.
cipd/commonPackage common defines structures and functions used by cipd/* packages.
cipd/versionPackage version provides a way for CIPD packaged Go binaries to discover their current package instance ID.
client/archiverPackage archiver implements the pipeline to efficiently archive file sets to an isolated server as fast as possible.
client/cmd/cloudkms
client/cmd/devshellCommand devshell is a Devshell server.
client/cmd/gerrit
client/cmd/git-credential-luciCommand git-credential-luci is a Git credential helper.
client/cmd/gitiles
client/cmd/gsutil-authCommand gsutil-auth implements "gsutil -> LUCI auth" shim server.
client/cmd/isolatePackage 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/isolatedPackage main is an Isolate server client.
client/cmd/swarmingPackage main is a client to a Swarming server.
client/downloaderPackage archiver implements the pipeline to efficiently archive file sets to an isolated server as fast as possible.
client/flagpbPackage flagpb defines a flag format for protobuf messages, implements a parser and a formatter.
client/internal/commonPackage common implements code and utilities shared across all packages in client/.
client/internal/progressPackage progress implements a progress indicator for text mode applications.
client/isolatePackage isolate implements the code to process '.isolate' files to generate '.isolated' files.
client/isolated
client/versioncliPackage versioncli implements a subcommand for obtaining version with the CLI.
common/api
common/api/buildbucket/buildbucket/v1Package buildbucket provides access to the Build Bucket Service.
common/api/buildbucket/swarmbucket/v1Package swarmbucket provides access to the Buildbucket-Swarming integration.
common/api/gerrit
common/api/gitilesPackage gitiles implements GitilesClient in "go.chromium.org/common/proto/gitiles" package on top of Gitiles's REST API.
common/api/isolate/isolateservice/v1Package isolateservice provides access to the .
common/api/luci_config/config/v1Package config provides access to the Configuration Service.
common/api/machine_provider/machine/v1Package machine provides access to the .
common/api/swarming/swarming/v1Package swarming provides access to the .
common/bqPackage bq is a library for working with BigQuery.
common/cliPackage cli is a helper package for "github.com/maruel/subcommands".
common/clockPackage clock is an interface to system time and timers which is easy to test.
common/clock/clockflag
common/clock/testclock
common/data/base128Package base128 implements base128 encoding and decoding.
common/data/bit_field
common/data/bit_field/tool
common/data/caching/cachePackage cache implements both in-memory and on-disk caching.
common/data/caching/cacheContextPackage cacheContext implements a context.Context wrapper which caches the results of Value calls, speeding up subsequent calls for the same key.
common/data/caching/lazyslotPackage lazyslot implements a caching scheme for globally shared objects that take significant time to refresh.
common/data/caching/lruPackage lru provides least-recently-used (LRU) cache.
common/data/chunkstream
common/data/cmpbinPackage 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/jsontimePackage jsontime implements a JSON-serializable container for a time.Time.
common/data/rand/cryptorandPackage cryptorand implements a mockable source or crypto strong randomness.
common/data/rand/mathrandPackage mathrand implements a mockable interface for math/rand.Rand.
common/data/recordioPackage recordio implements a basic RecordIO reader and writer.
common/data/sortbyPackage sortby provides a succinct way to generate correctly-behaved Less funcions for use with the stdlib 'sort' package.
common/data/stringsetPackage stringset is an exceedingly simple 'set' implementation for strings.
common/data/strpairPackage strpair implements parsing and formatting of lists of colon-delimited key-value pair strings.
common/data/text/indented
common/data/text/patternPackage pattern implements lightweight parsable string patterns.
common/data/text/sanitizehtmlPackage sanitizehtml implements a sanitizer of a very limited HTML.
common/data/text/stringtemplatePackage stringtemplate implements Python string.Template-like substitution.
common/data/text/templateprotoPackage templateproto defines a proto-based way to configure templates for JSON documents.
common/data/text/unitsPackage units provides common useful printable units.
common/data/treapstorePackage treapstore is a lightweight append-only in-memory key-value store built on top a treap (tree + heap) implementation.
common/errorsPackage errors is an augmented replacement package for the stdlib "errors" package.
common/flag
common/flag/fixflagpos
common/flag/flagenumPackage 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/multiflagPackage 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/nestedflagset
common/flag/stringlistflagPackage stringlistflag provides a flag.Value implementation which resolves multiple args into a []string.
common/flag/stringmapflagPackage stringmapflag provides a flag.Value that, when parsed, augments a map[string]string with the supplied parameter.
common/flag/stringsetflagPackage stringsetflag provides a flag.Value implementation which resolves multiple args into a stringset.
common/gcloud/gaePackage gae defines information about the AppEngine environment.
common/gcloud/googleoauthPackage googleoauth contains some helpers related to Google OAuth2.
common/gcloud/gsPackage gs implements a versatile Google Storage client on top of the standard Google Storage Go API.
common/gcloud/iamPackage iam implements wrappers around some Google Cloud IAM APIs.
common/gcloud/pubsub
common/iotoolsPackage iotools contains a collection of I/O-related utility structs and methods.
common/isolatedPackage isolated defines the isolated common code shared by the client and server.
common/isolatedclientPackage isolatedclient implements the API to communicate with the Isolated server and to process '.isolated' files.
common/isolatedclient/isolatedfakePackage isolatedfake implements an in-process fake Isolated server for integration testing.
common/lhttpPackage lhttp implements HTTP client helper code (JSON, automatic retries, authentication, etc).
common/loggingPackage logging defines Logger interface and context.Context helpers to put\get logger from context.Context.
common/logging/gkeloggerPackage gkelogger is a simple logger that outputs all log entries as single- line JSON objects to stdout.
common/logging/gologgerPackage gologger is a compatibility layer between go-logging library and luci-go/common/logging.
common/logging/memlogger
common/logging/teelogger
common/proto
common/proto/accessPackage access contains Access service protocol.
common/proto/configPackage config contains luci-config protobuf definitions.
common/proto/gerritPackage gerrit contains Gerrit service definition.
common/proto/gitPackage git contains Git-related protobuf definitions.
common/proto/gitilesPackage gitiles contains Gitiles service definition.
common/proto/googlePackage google contains utility methods to help interface between Google standard protobufs and native Go types.
common/proto/google/descutilPackage descutil contains utility functions for protobuf descriptor messages.
common/proto/miloPackage milo is a generated protocol buffer package.
common/proto/srcmanPackage srcman contains source manifest protobuf definitions.
common/retry
common/retry/transientPackage transient allows you to tag and retry 'transient' errors (i.e.
common/runtime/goroutinePackage goroutine is mostly to house a function for obtaining the current goroutine ID, but probably will eventually contain other naughty functions.
common/runtime/paniccatcherPackage paniccatcher package exposes a set of utility structures and methods that support standardized panic catching and handling.
common/runtime/profiling
common/runtime/tracerPackage tracer implements code to generate Chrome-compatible traces.
common/sync/bufferpoolPackage bufferpool implements a pool of bytes.Buffer instances backed by a sync.Pool.
common/sync/cancelcondPackage cancelcond implements a wrapper around sync.Cond that response to context.Context cancellation.
common/sync/mutexpoolPackage mutexpool implements P, a pool of keyed mutexes.
common/sync/parallel
common/sync/promise
common/system/environPackage environ is a simple environment variable manipulation library.
common/system/exitcodePackage exitcode provides common methods to extract exit codes from errors returned by exec.Cmd.
common/system/filesystem
common/system/proberPackage prober exports Probe, which implements logic to identify a wrapper's wrapped target.
common/system/terminalPackage terminal is just a way to forward
common/testing/assertionsPackage assertions is designed to be a collection of `.` importable, goconvey compatible testing assertions, in the style of "github.com/smartystreets/assertions".
common/testing/httpmitm
common/testing/prpctestPackage prpctest is a package to facilitate pRPC testing by wrapping httptest with a pRPC Server.
common/testing/testfs
common/tsmonPackage tsmon contains global state and utility functions for configuring and interacting with tsmon.
common/tsmon/distributionPackage distribution contains distribution metrics, fixed width and geometric bucketers.
common/tsmon/fieldPackage field contains constructors for metric field definitions.
common/tsmon/metricPackage metric is the API for defining metrics and updating their values.
common/tsmon/monitorPackage monitor contains the code for sending metric data to monitoring endpoints.
common/tsmon/registryPackage registry holds a map of all metrics registered by the process.
common/tsmon/runtimestatsPackage runtimestats exposes metrics related to the Go runtime.
common/tsmon/storePackage store contains code for storing and retreiving metrics.
common/tsmon/store/storetestPackage storetest is imported exclusively by tests for Store implementations.
common/tsmon/targetPackage target contains information about the thing that is sending metrics - either a NetworkDevice (a machine) or a Task (a service).
common/tsmon/ts_mon_protoPackage ts_mon_proto contains ts_mon protobuf source and generated protobuf data.
common/tsmon/typesPackage types contains miscellaneous structs and interfaces used throughout tsmon.
common/tsmon/versionsPackage versions allows processes to report string-valued metrics with versions of various libraries they link with.
configPackage config contains a client to access LUCI configuration service.
config/appengine/backend/datastore
config/appengine/backend/memcachePackage memcache implements a caching config client backend backed by AppEngine's memcache service.
config/appengine/gaeconfigPackage gaeconfig implements LUCI-config service bindings backed by AppEngine storage and caching.
config/impl/erroringPackage erroring implements a backend that always returns an error for all of its calls.
config/impl/filesystemPackage filesystem implements a file system backend for the config client.
config/impl/memoryPackage memory implements in-memory backend for the config client.
config/impl/remote
config/server/cfgclientPackage cfgclient contains service implementations for the LUCI configuration service defined in go.chromium.org/luci/config.
config/server/cfgclient/accessPackage access implements a config service access check against a project config client.
config/server/cfgclient/backendPackage backend implements configuration client backend interface and associated data types.
config/server/cfgclient/backend/cachingPackage caching implements a config.Interface that uses a caching layer to store its configuration values.
config/server/cfgclient/backend/clientPackage client implements a config client backend for a configuration client.
config/server/cfgclient/backend/erroringPackage erroring implements config.Backend that simply returns an error.
config/server/cfgclient/backend/formatPackage format implements a config client Backend that performs formatting on items.
config/server/cfgclient/backend/testconfig
config/server/cfgclient/textprotoPackage textproto implements a textproto config service Resolver.
config/validationPackage validation provides helpers for performing and setting up handlers for config validation related requests from luci-config.
dmPackage dm is the service and tooling for the Dungeon Master (DM) distributed dependency scheduling service.
dm/api/acls
dm/api/distributor
dm/api/distributor/jobsim
dm/api/distributor/swarming/v1
dm/api/service/v1
dm/api/template
dm/appenginePackage appengine provides the appengine service implementation for DM.
dm/appengine/depsPackage deps implements DM's Deps RPC methods.
dm/appengine/distributorPackage distributor contains all the adaptors for the various supported distributor protocols.
dm/appengine/distributor/fake
dm/appengine/distributor/jobsim
dm/appengine/distributor/swarming/v1
dm/appengine/frontendPackage frontend is DM's Google AppEngine application stub.
dm/appengine/modelPackage model contains all of DM's datastore models.
dm/appengine/mutatePackage mutate includes the main logic of DM's state machine.
dm/appengine/static
examples/appengine/helloworld_flex
examples/appengine/helloworld_standard/frontendPackage frontend implements HTTP server that handles requests to default module.
examples/appengine/helloworld_standard/proto
examples/appengine/helloworld_standard/static
grpc/cmd/cproto
grpc/cmd/prpcCommand prpc can make RPCs to pRPC servers and display their description.
grpc/cmd/svcdecCommand svcdec stands for 'service decorator'.
grpc/cmd/svcmuxCommand svcmux reads a service interface XYZServer generated by protoc and generates VersionedXYZV struct that stores a map version->implementation, and a default version.
grpc/discoveryPackage discovery implements RPC service introspection.
grpc/grpcmonPackage grpcmon defines gRPC interceptors with monitoring instrumentation.
grpc/grpcutilPackage grpcutil is a utility package to supplement Google's gRPC package, "google.golang.org/grpc".
grpc/internal/svctoolPackage svctool implements svcmux/svcdec tools command line parsing
grpc/loggingPackage logging implements a gRPC glog.Logger implementation backed by a go.chromium.org/luci/common/logging Logger.
grpc/prpcPackage prpc (provisional RPC) implements an RPC client over HTTP 1.x.
grpc/prpc/e2etest
grpc/prpc/talk/buildbot/client
grpc/prpc/talk/buildbot/frontend
grpc/prpc/talk/buildbot/proto
grpc/svcmuxPackage svcmux contains utility functions used by code generated by svcmux tool.
hardcoded/chromeinfraPackage chromeinfra contains hardcoded values related to Chrome Infra.
logdog/api/config/svcconfigPackage svcconfig stores service configuration for a LogDog instance.
logdog/api/config/svcconfig/validatePackage main implements the LogDog Coordinator validation binary.
logdog/api/endpoints/coordinator/admin/v1Package logdog contains Version 1 of the LogDog Coordinator service interface.
logdog/api/endpoints/coordinator/logs/v1Package logdog contains Version 1 of the LogDog Coordinator user interface.
logdog/api/endpoints/coordinator/logs/v1/fakelogs
logdog/api/endpoints/coordinator/registration/v1Package logdog contains Version 1 of the LogDog Coordinator stream registration interface.
logdog/api/endpoints/coordinator/services/v1Package logdog contains Version 1 of the LogDog Coordinator backend service interface.
logdog/api/logpbPackage logpb contains LogDog protobuf source and generated protobuf data.
logdog/appengine/coordinator
logdog/appengine/coordinator/config
logdog/appengine/coordinator/coordinatorTest
logdog/appengine/coordinator/endpoints
logdog/appengine/coordinator/endpoints/admin
logdog/appengine/coordinator/endpoints/registration
logdog/appengine/coordinator/endpoints/services
logdog/appengine/coordinator/flex
logdog/appengine/coordinator/flex/logs
logdog/appengine/coordinator/mutations
logdog/client/annotee
logdog/client/annotee/annotationPackage annotation implements a state machine that constructs Milo annotation protobufs from a series of annotation commands.
logdog/client/annotee/executorPackage executor contains an implementation of the Annotee Executor.
logdog/client/bootstrapResultPackage bootstrapResult defines a common way to express the result of bootstrapping a command via JSON.
logdog/client/butlerPackage butler is the main engine for the Butler executable.
logdog/client/butler/bootstrapPackage bootstrap handles Butler-side bootstrapping functionality.
logdog/client/butler/bundlerPackage bundler is responsible for efficiently transforming aggregate stream data into Butler messages for export.
logdog/client/butlerlib/bootstrap
logdog/client/butlerlib/streamclient
logdog/client/butlerlib/streamprotoPackage streamproto describes the protocol primitives used by LogDog/Butler for stream negotiation.
logdog/client/butler/outputPackage output contains interfaces and implementations for Butler Outputs, which are responsible for delivering Butler protobufs to LogDog collection endpoints.
logdog/client/butler/output/file
logdog/client/butler/output/logPackage log implements the "log" Output.
logdog/client/butler/output/logdog
logdog/client/butler/output/pubsubPackage pubsub implements the "pubsub" Output.
logdog/client/butlerprotoPackage butlerproto implements the LogDog Butler wire protocol.
logdog/client/butler/streamserver
logdog/client/butler/streamserver/localclient
logdog/client/cli
logdog/client/cmd/logdog
logdog/client/cmd/logdog_annotee
logdog/client/cmd/logdog_butlerPackage main is entry point for the command-line LogDog Butler application.
logdog/client/coordinator
logdog/common/archivePackage archive constructs a LogDog archive out of log stream components.
logdog/common/fetcher
logdog/common/rendererPackage renderer exports the capability to render a LogDog log stream to an io.Writer.
logdog/common/storage
logdog/common/storage/archivePackage archive implements a storage.Storage instance that retrieves logs from a Google Storage archive.
logdog/common/storage/archive/logdog_archive_testPackage main implements a simple CLI tool to load and interact with Google Storage archived data.
logdog/common/storage/bigtablePackage bigtable provides an implementation of the Storage interface backed by Google Cloud Platform's BigTable.
logdog/common/storage/bigtable/logdog_bigtable_testPackage main implements a simple CLI tool to load and interact with storage data in Google BigTable data.
logdog/common/storage/memoryPackage memory implements in-memory Storage structures.
logdog/common/types
logdog/common/viewerPackage viewer is a support library to interact with the LogDog web app and log stream viewer.
logdog/server/archivist
logdog/server/bundleServicesClient
logdog/server/collectorPackage collector implements the LogDog Collector daemon's log parsing and registration logic.
logdog/server/collector/coordinatorPackage coordinator implements a minimal interface to the Coordinator service that is sufficient for Collector usage.
logdog/server/retryServicesClient
logdog/server/service
logdog/server/service/configPackage config implements common LogDog daemon configuration.
lucictxPackage lucictx implements a Go client for the protocol defined here: https://github.com/luci/luci-py/blob/master/client/LUCI_CONTEXT.md
luci_notify/api/config
luci_notify/config
luci_notify/frontend
luci_notify/internalPackage internal is a generated protocol buffer package.
luci_notify/notify
luci_notify/testutil
machine-db/api/common/v1
machine-db/api/crimson/v1
machine-db/client/cliPackage cli contains the Machine Database command-line client.
machine-db/commonPackage common contains common Machine Database functions.
milo/api/buildbotPackage protocol defines types used in Buildbot build protocol, e.g.
milo/api/config
milo/api/proto
milo/buildsource
milo/buildsource/buildbot
milo/buildsource/buildbot/buildstorePackage buildstore implements storage of //milo/api/buildbot/* types.
milo/buildsource/buildbucket
milo/buildsource/rawpresentation
milo/buildsource/rawpresentation/internal
milo/buildsource/swarming
milo/common
milo/common/model
milo/frontend
milo/frontend/appengine
milo/frontend/ui
milo/gitPackage git provides high level API for Git/Gerrit data.
milo/git/gitaclsPackage gitacls implements read ACLs for Git/Gerrit data.
milo/git/gittestPackage gittest is a generated GoMock package.
milo/rpc
scheduler/api/scheduler/v1Package scheduler contains the main API of Scheduler service.
scheduler/appengine/aclpackage acl implements ACLs for enforcement in API and UI.
scheduler/appengine/apiserversPackage apiservers implements gRPC APIs exposed by Scheduler service.
scheduler/appengine/catalogPackage catalog implements a part that talks to luci-config service to fetch and parse job definitions.
scheduler/appengine/enginePackage engine implements the core logic of the scheduler service.
scheduler/appengine/engine/cron
scheduler/appengine/engine/dssetPackage dsset implements a particular flavor of datastore-backed set.
scheduler/appengine/engine/policyPackage policy contains implementation of triggering policy functions.
scheduler/appengine/frontendPackage frontend implements GAE web server for luci-scheduler service.
scheduler/appengine/internalPackage internal contains internal structs used by the tasks and the engine.
scheduler/appengine/messages
scheduler/appengine/presentationpackage presentation implements common method to API and UI serving.
scheduler/appengine/schedule
scheduler/appengine/static
scheduler/appengine/taskPackage task defines interface between Scheduler engine and implementations of particular tasks (such as URL fetch tasks, Swarming tasks, DM tasks, etc).
scheduler/appengine/task/buildbucketPackage buildbucket implements tasks that run Buildbucket jobs.
scheduler/appengine/task/gitiles
scheduler/appengine/task/noopPackage noop implements tasks that do nothing at all.
scheduler/appengine/task/urlfetchPackage urlfetch implements tasks that just make HTTP calls.
scheduler/appengine/task/utilsPackage utils contains a bunch of small functions used by task/ subpackages.
scheduler/appengine/task/utils/tasktest
scheduler/appengine/uiPackage ui implements request handlers that serve user facing HTML pages.
server/analyticsPackage analytics provides a standard way to store the Google Analytics tracking ID.
server/authPackage auth implements authentication and authorization framework for HTTP servers.
server/auth/authdbPackage authdb contains definition of Authentication Database (aka AuthDB).
server/auth/authtestPackage authtest implements some interfaces used by auth package to simplify unit testing.
server/auth/delegationPackage delegation contains low-level API for working with delegation tokens.
server/auth/delegation/messages
server/auth/internal
server/auth/openidPackage openid implements OpenID Connect Login protocol (client side).
server/auth/servicePackage service implements a wrapper around API exposed by auth_service: https://github.com/luci/luci-py/tree/master/appengine/auth_service
server/auth/service/protocol
server/auth/signingPackage signing provides interfaces to sign arbitrary small blobs with RSA-SHA256 signature (PKCS1v15) and verify such signatures.
server/auth/signing/signingtestPackage signingtest implements signing.Signer interface using small random keys.
server/auth/xsrfPackage xsrf provides Cross Site Request Forgery prevention middleware.
server/cachingPackage caching implements common server object caches.
server/caching/cachingtestPackage cachingtest contains helpers for testing code that uses caching package.
server/caching/layeredPackage layered provides a two-layer cache for serializable objects.
server/middlewarePackage middleware defines base type for context-aware HTTP request handler.
server/portalPackage portal implements HTTP routes for portal pages.
server/portal/internal/assetsPackage assets is generated by go.chromium.org/luci/tools/cmd/assets.
server/pprofPackage pprof is similar to net/http/pprof, except it supports auth.
server/pprof/internal
server/routerPackage router provides an HTTP router with support for middleware and subrouters.
server/secretsPackage 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/testsecretsPackage testsecrets provides a dumb in-memory secret store to use in unit tests.
server/settingsPackage settings implements storage for infrequently changing global settings.
server/templatesPackage templates implements wrapper around html/template to provide lazy loading of templates and better integration with HTTP middleware framework.
server/tokensPackage tokens provides means to generate and validate base64 encoded tokens compatible with luci-py's components.auth implementation.
server/tsmonPackage tsmon adapts common/tsmon library to a server-side environment.
server/warmupPackage warmup allows to register hooks executed during the server warmup.
skylark/interpreterPackage interpreter contains basic skylark interpreter with some features that make it useful for non-trivial scripts:
skylark/skylarkprotoPackage skylarkproto exposes protobuf messages as skylark types.
skylark/skylarkproto/testprotos
tokenserver/apiPackage tokenserver contains common protobuf messages for the token server.
tokenserver/api/admin/v1Package admin contains The Token Server Administrative and Config API.
tokenserver/api/minter/v1Package minter contains the main API of the token server.
tokenserver/appengine/backendPackage backend implements HTTP server that handles requests to 'backend' module.
tokenserver/appengine/frontendPackage frontend implements HTTP server that handles requests to 'default' module.
tokenserver/appengine/impl/certcheckerPackage certchecker contains implementation of CertChecker.
tokenserver/appengine/impl/certconfigPackage certconfig contains code to work with imported CAs and their CRLs.
tokenserver/appengine/impl/delegation
tokenserver/appengine/impl/machinetokenPackage machinetoken implements generation of LUCI machine tokens.
tokenserver/appengine/impl/serviceaccounts
tokenserver/appengine/impl/services/admin/adminsrvPackage adminsrv implements Admin API.
tokenserver/appengine/impl/services/admin/certauthoritiesPackage certauthorities implements CertificateAuthorities API.
tokenserver/appengine/impl/services/minter/tokenminterPackage tokenminter implements TokenMinter API.
tokenserver/appengine/impl/utilsPackage utils contains a variety of small utility functions used by other tokenserver packages.
tokenserver/appengine/impl/utils/bqlogPackage bqlog provides a mechanism to asynchronously log rows to BigQuery.
tokenserver/appengine/impl/utils/identitysetPackage identityset implements a set-like structure for identity.Identity.
tokenserver/appengine/impl/utils/policyPackage policy contains implementation of Policy parsing and querying.
tokenserver/appengine/impl/utils/revocationPackage revocation contains utilities for implementing token revocation.
tokenserver/appengine/impl/utils/shardsPackage shards provides a low level support for implementing sharded set of []byte blobs.
tokenserver/appengine/impl/utils/tokensigningPackage tokensigning implements utilities for RSA-signing of proto messages.
tokenserver/appengine/static
tokenserver/clientPackage client implements pRPC client for The Token Server.
tools/cmd/apigenPackage main hosts the Cloud Endpoints API generator utility.
tools/cmd/assetsPackage 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/bqschemaupdaterCommand bqschemaupdater accepts location and schema of a BigQuery table and creates or updates the table.
tools/cmd/gorunPackage main defines the `gorun` tool, a shorthand tool to extend the "go run"-like convenience to packages.
tools/internal/apigen
tumblePackage tumble is a distributed multi-stage transaction processor for appengine.
vpythonPackage vpython implements the vpython tool and associated libraries.
vpython/api/vpythonPackage vpython contains `vpython` environment definition protobufs.
vpython/application
vpython/cipd
vpython/python
vpython/spec
vpython/venv
vpython/venv/assetsPackage assets is generated by go.chromium.org/luci/tools/cmd/assets.
vpython/wheel

Updated 2018-09-21. Refresh now. Tools for package owners.