diff --git a/cmd/registry-api-descriptor-template/main.go b/cmd/registry-api-descriptor-template/main.go index e69e6b2cf..a69adeb0c 100644 --- a/cmd/registry-api-descriptor-template/main.go +++ b/cmd/registry-api-descriptor-template/main.go @@ -4,7 +4,7 @@ // For example, to generate a new API specification, one would execute the // following command from the repo root: // -// $ registry-api-descriptor-template docs/spec/api.md.tmpl > docs/spec/api.md +// $ registry-api-descriptor-template docs/spec/api.md.tmpl > docs/spec/api.md // // The templates are passed in the api/v2.APIDescriptor object. Please see the // package documentation for fields available on that object. The template diff --git a/configuration/configuration.go b/configuration/configuration.go index dd3154856..962701d4c 100644 --- a/configuration/configuration.go +++ b/configuration/configuration.go @@ -584,7 +584,7 @@ type Events struct { IncludeReferences bool `yaml:"includereferences"` // include reference data in manifest events } -//Ignore configures mediaTypes and actions of the event, that it won't be propagated +// Ignore configures mediaTypes and actions of the event, that it won't be propagated type Ignore struct { MediaTypes []string `yaml:"mediatypes"` // target media types to ignore Actions []string `yaml:"actions"` // ignore action types diff --git a/context/doc.go b/context/doc.go index 0c631a9c9..51376dd69 100644 --- a/context/doc.go +++ b/context/doc.go @@ -4,68 +4,68 @@ // // The easiest way to get started is to get the background context: // -// ctx := context.Background() +// ctx := context.Background() // // The returned context should be passed around your application and be the // root of all other context instances. If the application has a version, this // line should be called before anything else: // -// ctx := context.WithVersion(context.Background(), version) +// ctx := context.WithVersion(context.Background(), version) // // The above will store the version in the context and will be available to // the logger. // -// Logging +// # Logging // // The most useful aspect of this package is GetLogger. This function takes // any context.Context interface and returns the current logger from the // context. Canonical usage looks like this: // -// GetLogger(ctx).Infof("something interesting happened") +// GetLogger(ctx).Infof("something interesting happened") // // GetLogger also takes optional key arguments. The keys will be looked up in // the context and reported with the logger. The following example would // return a logger that prints the version with each log message: // -// ctx := context.Context(context.Background(), "version", version) -// GetLogger(ctx, "version").Infof("this log message has a version field") +// ctx := context.Context(context.Background(), "version", version) +// GetLogger(ctx, "version").Infof("this log message has a version field") // // The above would print out a log message like this: // -// INFO[0000] this log message has a version field version=v2.0.0-alpha.2.m +// INFO[0000] this log message has a version field version=v2.0.0-alpha.2.m // // When used with WithLogger, we gain the ability to decorate the context with // loggers that have information from disparate parts of the call stack. // Following from the version example, we can build a new context with the // configured logger such that we always print the version field: // -// ctx = WithLogger(ctx, GetLogger(ctx, "version")) +// ctx = WithLogger(ctx, GetLogger(ctx, "version")) // // Since the logger has been pushed to the context, we can now get the version // field for free with our log messages. Future calls to GetLogger on the new // context will have the version field: // -// GetLogger(ctx).Infof("this log message has a version field") +// GetLogger(ctx).Infof("this log message has a version field") // // This becomes more powerful when we start stacking loggers. Let's say we // have the version logger from above but also want a request id. Using the // context above, in our request scoped function, we place another logger in // the context: // -// ctx = context.WithValue(ctx, "http.request.id", "unique id") // called when building request context -// ctx = WithLogger(ctx, GetLogger(ctx, "http.request.id")) +// ctx = context.WithValue(ctx, "http.request.id", "unique id") // called when building request context +// ctx = WithLogger(ctx, GetLogger(ctx, "http.request.id")) // // When GetLogger is called on the new context, "http.request.id" will be // included as a logger field, along with the original "version" field: // -// INFO[0000] this log message has a version field http.request.id=unique id version=v2.0.0-alpha.2.m +// INFO[0000] this log message has a version field http.request.id=unique id version=v2.0.0-alpha.2.m // // Note that this only affects the new context, the previous context, with the // version field, can be used independently. Put another way, the new logger, // added to the request context, is unique to that context and can have // request scoped variables. // -// HTTP Requests +// # HTTP Requests // // This package also contains several methods for working with http requests. // The concepts are very similar to those described above. We simply place the @@ -73,13 +73,13 @@ // available. GetRequestLogger can then be called to get request specific // variables in a log line: // -// ctx = WithRequest(ctx, req) -// GetRequestLogger(ctx).Infof("request variables") +// ctx = WithRequest(ctx, req) +// GetRequestLogger(ctx).Infof("request variables") // // Like above, if we want to include the request data in all log messages in // the context, we push the logger to a new context and use that one: // -// ctx = WithLogger(ctx, GetRequestLogger(ctx)) +// ctx = WithLogger(ctx, GetRequestLogger(ctx)) // // The concept is fairly powerful and ensures that calls throughout the stack // can be traced in log messages. Using the fields like "http.request.id", one diff --git a/context/trace.go b/context/trace.go index 5b88ddaf4..092ef608c 100644 --- a/context/trace.go +++ b/context/trace.go @@ -24,16 +24,16 @@ import ( // // Here is an example of the usage: // -// func timedOperation(ctx Context) { -// ctx, done := WithTrace(ctx) -// defer done("this will be the log message") -// // ... function body ... -// } +// func timedOperation(ctx Context) { +// ctx, done := WithTrace(ctx) +// defer done("this will be the log message") +// // ... function body ... +// } // // If the function ran for roughly 1s, such a usage would emit a log message // as follows: // -// INFO[0001] this will be the log message trace.duration=1.004575763s trace.func=github.com/docker/distribution/context.traceOperation trace.id= ... +// INFO[0001] this will be the log message trace.duration=1.004575763s trace.func=github.com/docker/distribution/context.traceOperation trace.id= ... // // Notice that the function name is automatically resolved, along with the // package and a trace id is emitted that can be linked with parent ids. diff --git a/health/doc.go b/health/doc.go index 877f4daca..5e5ba2fc0 100644 --- a/health/doc.go +++ b/health/doc.go @@ -13,29 +13,29 @@ // particularly useful for checks that verify upstream connectivity or // database status, since they might take a long time to return/timeout. // -// Installing +// # Installing // // To install health, just import it in your application: // -// import "github.com/docker/distribution/health" +// import "github.com/docker/distribution/health" // // You can also (optionally) import "health/api" that will add two convenience // endpoints: "/debug/health/down" and "/debug/health/up". These endpoints add // "manual" checks that allow the service to quickly be brought in/out of // rotation. // -// import _ "github.com/docker/distribution/health/api" +// import _ "github.com/docker/distribution/health/api" // -// # curl localhost:5001/debug/health -// {} -// # curl -X POST localhost:5001/debug/health/down -// # curl localhost:5001/debug/health -// {"manual_http_status":"Manual Check"} +// # curl localhost:5001/debug/health +// {} +// # curl -X POST localhost:5001/debug/health/down +// # curl localhost:5001/debug/health +// {"manual_http_status":"Manual Check"} // // After importing these packages to your main application, you can start // registering checks. // -// Registering Checks +// # Registering Checks // // The recommended way of registering checks is using a periodic Check. // PeriodicChecks run on a certain schedule and asynchronously update the @@ -45,22 +45,22 @@ // A trivial example of a check that runs every 5 seconds and shuts down our // server if the current minute is even, could be added as follows: // -// func currentMinuteEvenCheck() error { -// m := time.Now().Minute() -// if m%2 == 0 { -// return errors.New("Current minute is even!") -// } -// return nil -// } +// func currentMinuteEvenCheck() error { +// m := time.Now().Minute() +// if m%2 == 0 { +// return errors.New("Current minute is even!") +// } +// return nil +// } // -// health.RegisterPeriodicFunc("minute_even", currentMinuteEvenCheck, time.Second*5) +// health.RegisterPeriodicFunc("minute_even", currentMinuteEvenCheck, time.Second*5) // // Alternatively, you can also make use of "RegisterPeriodicThresholdFunc" to // implement the exact same check, but add a threshold of failures after which // the check will be unhealthy. This is particularly useful for flaky Checks, // ensuring some stability of the service when handling them. // -// health.RegisterPeriodicThresholdFunc("minute_even", currentMinuteEvenCheck, time.Second*5, 4) +// health.RegisterPeriodicThresholdFunc("minute_even", currentMinuteEvenCheck, time.Second*5, 4) // // The lowest-level way to interact with the health package is calling // "Register" directly. Register allows you to pass in an arbitrary string and @@ -72,7 +72,7 @@ // Assuming you wish to register a method called "currentMinuteEvenCheck() // error" you could do that by doing: // -// health.Register("even_minute", health.CheckFunc(currentMinuteEvenCheck)) +// health.Register("even_minute", health.CheckFunc(currentMinuteEvenCheck)) // // CheckFunc is a convenience type that implements Checker. // @@ -80,11 +80,11 @@ // and the convenience method RegisterFunc. An example that makes the status // endpoint always return an error: // -// health.RegisterFunc("my_check", func() error { -// return Errors.new("This is an error!") -// })) +// health.RegisterFunc("my_check", func() error { +// return Errors.new("This is an error!") +// })) // -// Examples +// # Examples // // You could also use the health checker mechanism to ensure your application // only comes up if certain conditions are met, or to allow the developer to @@ -92,35 +92,35 @@ // database connectivity and immediately takes the server out of rotation on // err: // -// updater = health.NewStatusUpdater() -// health.RegisterFunc("database_check", func() error { -// return updater.Check() -// })) +// updater = health.NewStatusUpdater() +// health.RegisterFunc("database_check", func() error { +// return updater.Check() +// })) // -// conn, err := Connect(...) // database call here -// if err != nil { -// updater.Update(errors.New("Error connecting to the database: " + err.Error())) -// } +// conn, err := Connect(...) // database call here +// if err != nil { +// updater.Update(errors.New("Error connecting to the database: " + err.Error())) +// } // // You can also use the predefined Checkers that come included with the health // package. First, import the checks: // -// import "github.com/docker/distribution/health/checks +// import "github.com/docker/distribution/health/checks // // After that you can make use of any of the provided checks. An example of // using a `FileChecker` to take the application out of rotation if a certain // file exists can be done as follows: // -// health.Register("fileChecker", health.PeriodicChecker(checks.FileChecker("/tmp/disable"), time.Second*5)) +// health.Register("fileChecker", health.PeriodicChecker(checks.FileChecker("/tmp/disable"), time.Second*5)) // // After registering the check, it is trivial to take an application out of // rotation from the console: // -// # curl localhost:5001/debug/health -// {} -// # touch /tmp/disable -// # curl localhost:5001/debug/health -// {"fileChecker":"file exists"} +// # curl localhost:5001/debug/health +// {} +// # touch /tmp/disable +// # curl localhost:5001/debug/health +// {"fileChecker":"file exists"} // // FileChecker only accepts absolute or relative file path. It does not work // properly with tilde(~). You should make sure that the application has @@ -132,5 +132,5 @@ // "HTTPChecker", but ensure that you only mark the test unhealthy if there // are a minimum of two failures in a row: // -// health.Register("httpChecker", health.PeriodicThresholdChecker(checks.HTTPChecker("https://www.google.pt"), time.Second*5, 2)) +// health.Register("httpChecker", health.PeriodicThresholdChecker(checks.HTTPChecker("https://www.google.pt"), time.Second*5, 2)) package health diff --git a/reference/reference.go b/reference/reference.go index 8c0c23b2f..b7cd00b0d 100644 --- a/reference/reference.go +++ b/reference/reference.go @@ -3,13 +3,13 @@ // // Grammar // -// reference := name [ ":" tag ] [ "@" digest ] +// reference := name [ ":" tag ] [ "@" digest ] // name := [domain '/'] path-component ['/' path-component]* // domain := domain-component ['.' domain-component]* [':' port-number] // domain-component := /([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9])/ // port-number := /[0-9]+/ // path-component := alpha-numeric [separator alpha-numeric]* -// alpha-numeric := /[a-z0-9]+/ +// alpha-numeric := /[a-z0-9]+/ // separator := /[_.]|__|[-]*/ // // tag := /[\w][\w.-]{0,127}/ diff --git a/registry/auth/auth.go b/registry/auth/auth.go index 835eff73d..9cb036f1f 100644 --- a/registry/auth/auth.go +++ b/registry/auth/auth.go @@ -8,28 +8,27 @@ // An implementation registers its access controller by name with a constructor // which accepts an options map for configuring the access controller. // -// options := map[string]interface{}{"sillySecret": "whysosilly?"} -// accessController, _ := auth.GetAccessController("silly", options) +// options := map[string]interface{}{"sillySecret": "whysosilly?"} +// accessController, _ := auth.GetAccessController("silly", options) // // This `accessController` can then be used in a request handler like so: // -// func updateOrder(w http.ResponseWriter, r *http.Request) { -// orderNumber := r.FormValue("orderNumber") -// resource := auth.Resource{Type: "customerOrder", Name: orderNumber} -// access := auth.Access{Resource: resource, Action: "update"} +// func updateOrder(w http.ResponseWriter, r *http.Request) { +// orderNumber := r.FormValue("orderNumber") +// resource := auth.Resource{Type: "customerOrder", Name: orderNumber} +// access := auth.Access{Resource: resource, Action: "update"} // -// if ctx, err := accessController.Authorized(ctx, access); err != nil { -// if challenge, ok := err.(auth.Challenge) { -// // Let the challenge write the response. -// challenge.SetHeaders(r, w) -// w.WriteHeader(http.StatusUnauthorized) -// return -// } else { -// // Some other error. -// } +// if ctx, err := accessController.Authorized(ctx, access); err != nil { +// if challenge, ok := err.(auth.Challenge) { +// // Let the challenge write the response. +// challenge.SetHeaders(r, w) +// w.WriteHeader(http.StatusUnauthorized) +// return +// } else { +// // Some other error. // } -// } -// +// } +// } package auth import ( diff --git a/registry/auth/token/token.go b/registry/auth/token/token.go index 7f87d496f..f803415fe 100644 --- a/registry/auth/token/token.go +++ b/registry/auth/token/token.go @@ -185,13 +185,15 @@ func (t *Token) Verify(verifyOpts VerifyOptions) error { // VerifySigningKey attempts to get the key which was used to sign this token. // The token header should contain either of these 3 fields: -// `x5c` - The x509 certificate chain for the signing key. Needs to be -// verified. -// `jwk` - The JSON Web Key representation of the signing key. -// May contain its own `x5c` field which needs to be verified. -// `kid` - The unique identifier for the key. This library interprets it -// as a libtrust fingerprint. The key itself can be looked up in -// the trustedKeys field of the given verify options. +// +// `x5c` - The x509 certificate chain for the signing key. Needs to be +// verified. +// `jwk` - The JSON Web Key representation of the signing key. +// May contain its own `x5c` field which needs to be verified. +// `kid` - The unique identifier for the key. This library interprets it +// as a libtrust fingerprint. The key itself can be looked up in +// the trustedKeys field of the given verify options. +// // Each of these methods are tried in that order of preference until the // signing key is found or an error is returned. func (t *Token) VerifySigningKey(verifyOpts VerifyOptions) (signingKey libtrust.PublicKey, err error) { diff --git a/registry/auth/token/token_test.go b/registry/auth/token/token_test.go index 69f3e78b6..ec80d1bc8 100644 --- a/registry/auth/token/token_test.go +++ b/registry/auth/token/token_test.go @@ -307,10 +307,10 @@ func writeTempRootCerts(rootKeys []libtrust.PrivateKey) (filename string, err er // TestAccessController tests complete integration of the token auth package. // It starts by mocking the options for a token auth accessController which // it creates. It then tries a few mock requests: -// - don't supply a token; should error with challenge -// - supply an invalid token; should error with challenge -// - supply a token with insufficient access; should error with challenge -// - supply a valid token; should not error +// - don't supply a token; should error with challenge +// - supply an invalid token; should error with challenge +// - supply a token with insufficient access; should error with challenge +// - supply a valid token; should not error func TestAccessController(t *testing.T) { // Make 2 keys; only the first is to be a trusted root key. rootKeys, err := makeRootKeys(2) diff --git a/registry/storage/driver/base/base.go b/registry/storage/driver/base/base.go index 4511f0021..83b8c423b 100644 --- a/registry/storage/driver/base/base.go +++ b/registry/storage/driver/base/base.go @@ -6,14 +6,14 @@ // struct such that calls are proxied through this implementation. First, // declare the internal driver, as follows: // -// type driver struct { ... internal ...} +// type driver struct { ... internal ...} // // The resulting type should implement StorageDriver such that it can be the // target of a Base struct. The exported type can then be declared as follows: // -// type Driver struct { -// Base -// } +// type Driver struct { +// Base +// } // // Because Driver embeds Base, it effectively implements Base. If the driver // needs to intercept a call, before going to base, Driver should implement @@ -23,15 +23,15 @@ // To further shield the embed from other packages, it is recommended to // employ a private embed struct: // -// type baseEmbed struct { -// base.Base -// } +// type baseEmbed struct { +// base.Base +// } // // Then, declare driver to embed baseEmbed, rather than Base directly: // -// type Driver struct { -// baseEmbed -// } +// type Driver struct { +// baseEmbed +// } // // The type now implements StorageDriver, proxying through Base, without // exporting an unnecessary field. diff --git a/registry/storage/driver/base/regulator.go b/registry/storage/driver/base/regulator.go index 9c5e6cc41..df6e50385 100644 --- a/registry/storage/driver/base/regulator.go +++ b/registry/storage/driver/base/regulator.go @@ -145,7 +145,7 @@ func (r *regulator) Stat(ctx context.Context, path string) (storagedriver.FileIn } // List returns a list of the objects that are direct descendants of the -//given path. +// given path. func (r *regulator) List(ctx context.Context, path string) ([]string, error) { r.enter() defer r.exit() diff --git a/registry/storage/driver/middleware/cloudfront/middleware.go b/registry/storage/driver/middleware/cloudfront/middleware.go index ab3b2ca4a..632578310 100644 --- a/registry/storage/driver/middleware/cloudfront/middleware.go +++ b/registry/storage/driver/middleware/cloudfront/middleware.go @@ -1,6 +1,5 @@ // Package middleware - cloudfront wrapper for storage libs // N.B. currently only works with S3, not arbitrary sites -// package middleware import ( @@ -38,7 +37,9 @@ var _ storagedriver.StorageDriver = &cloudFrontStorageMiddleware{} // Optional options: ipFilteredBy, awsregion // ipfilteredby: valid value "none|aws|awsregion". "none", do not filter any IP, default value. "aws", only aws IP goes -// to S3 directly. "awsregion", only regions listed in awsregion options goes to S3 directly +// +// to S3 directly. "awsregion", only regions listed in awsregion options goes to S3 directly +// // awsregion: a comma separated string of AWS regions. func newCloudFrontStorageMiddleware(storageDriver storagedriver.StorageDriver, options map[string]interface{}) (storagedriver.StorageDriver, error) { // parse baseurl diff --git a/registry/storage/driver/s3-aws/s3.go b/registry/storage/driver/s3-aws/s3.go index d9c1a8269..b987b2f62 100644 --- a/registry/storage/driver/s3-aws/s3.go +++ b/registry/storage/driver/s3-aws/s3.go @@ -82,7 +82,7 @@ var validRegions = map[string]struct{}{} // validObjectACLs contains known s3 object Acls var validObjectACLs = map[string]struct{}{} -//DriverParameters A struct that encapsulates all of the driver parameters after all values have been set +// DriverParameters A struct that encapsulates all of the driver parameters after all values have been set type DriverParameters struct { AccessKey string SecretKey string diff --git a/registry/storage/ocimanifesthandler.go b/registry/storage/ocimanifesthandler.go index e06ecb113..6fa499fe7 100644 --- a/registry/storage/ocimanifesthandler.go +++ b/registry/storage/ocimanifesthandler.go @@ -12,7 +12,7 @@ import ( v1 "github.com/opencontainers/image-spec/specs-go/v1" ) -//ocischemaManifestHandler is a ManifestHandler that covers ocischema manifests. +// ocischemaManifestHandler is a ManifestHandler that covers ocischema manifests. type ocischemaManifestHandler struct { repository distribution.Repository blobStore distribution.BlobStore diff --git a/registry/storage/paths.go b/registry/storage/paths.go index 2d1f5132f..b8f327267 100644 --- a/registry/storage/paths.go +++ b/registry/storage/paths.go @@ -23,25 +23,25 @@ const ( // // The path layout in the storage backend is roughly as follows: // -// /v2 -// -> repositories/ -// ->/ -// -> _manifests/ -// revisions -// -> -// -> link -// tags/ -// -> current/link -// -> index -// -> //link -// -> _layers/ -// -// -> _uploads/ -// data -// startedat -// hashstates// -// -> blob/ -// +// /v2 +// -> repositories/ +// ->/ +// -> _manifests/ +// revisions +// -> +// -> link +// tags/ +// -> current/link +// -> index +// -> //link +// -> _layers/ +// +// -> _uploads/ +// data +// startedat +// hashstates// +// -> blob/ +// // // The storage backend layout is broken up into a content-addressable blob // store and repositories. The content-addressable blob store holds most data @@ -71,35 +71,35 @@ const ( // // Manifests: // -// manifestRevisionsPathSpec: /v2/repositories//_manifests/revisions/ -// manifestRevisionPathSpec: /v2/repositories//_manifests/revisions/// -// manifestRevisionLinkPathSpec: /v2/repositories//_manifests/revisions///link +// manifestRevisionsPathSpec: /v2/repositories//_manifests/revisions/ +// manifestRevisionPathSpec: /v2/repositories//_manifests/revisions/// +// manifestRevisionLinkPathSpec: /v2/repositories//_manifests/revisions///link // // Tags: // -// manifestTagsPathSpec: /v2/repositories//_manifests/tags/ -// manifestTagPathSpec: /v2/repositories//_manifests/tags// -// manifestTagCurrentPathSpec: /v2/repositories//_manifests/tags//current/link -// manifestTagIndexPathSpec: /v2/repositories//_manifests/tags//index/ -// manifestTagIndexEntryPathSpec: /v2/repositories//_manifests/tags//index/// -// manifestTagIndexEntryLinkPathSpec: /v2/repositories//_manifests/tags//index///link +// manifestTagsPathSpec: /v2/repositories//_manifests/tags/ +// manifestTagPathSpec: /v2/repositories//_manifests/tags// +// manifestTagCurrentPathSpec: /v2/repositories//_manifests/tags//current/link +// manifestTagIndexPathSpec: /v2/repositories//_manifests/tags//index/ +// manifestTagIndexEntryPathSpec: /v2/repositories//_manifests/tags//index/// +// manifestTagIndexEntryLinkPathSpec: /v2/repositories//_manifests/tags//index///link // -// Blobs: +// Blobs: // -// layerLinkPathSpec: /v2/repositories//_layers///link +// layerLinkPathSpec: /v2/repositories//_layers///link // // Uploads: // -// uploadDataPathSpec: /v2/repositories//_uploads//data -// uploadStartedAtPathSpec: /v2/repositories//_uploads//startedat -// uploadHashStatePathSpec: /v2/repositories//_uploads//hashstates// +// uploadDataPathSpec: /v2/repositories//_uploads//data +// uploadStartedAtPathSpec: /v2/repositories//_uploads//startedat +// uploadHashStatePathSpec: /v2/repositories//_uploads//hashstates// // // Blob Store: // // blobsPathSpec: /v2/blobs/ -// blobPathSpec: /v2/blobs/// -// blobDataPathSpec: /v2/blobs////data -// blobMediaTypePathSpec: /v2/blobs////data +// blobPathSpec: /v2/blobs/// +// blobDataPathSpec: /v2/blobs////data +// blobMediaTypePathSpec: /v2/blobs////data // // For more information on the semantic meaning of each path and their // contents, please see the path spec documentation. @@ -339,11 +339,11 @@ func (manifestTagIndexEntryLinkPathSpec) pathSpec() {} // blob id. The blob link will contain a content addressable blob id reference // into the blob store. The format of the contents is as follows: // -// : +// : // // The following example of the file contents is more illustrative: // -// sha256:96443a84ce518ac22acb2e985eda402b58ac19ce6f91980bde63726a79d80b36 +// sha256:96443a84ce518ac22acb2e985eda402b58ac19ce6f91980bde63726a79d80b36 // // This indicates that there is a blob with the id/digest, calculated via // sha256 that can be fetched from the blob store. @@ -429,13 +429,12 @@ func (repositoriesRootPathSpec) pathSpec() {} // digestPathComponents provides a consistent path breakdown for a given // digest. For a generic digest, it will be as follows: // -// / +// / // // If multilevel is true, the first two bytes of the digest will separate // groups of digest folder. It will be as follows: // -// // -// +// // func digestPathComponents(dgst digest.Digest, multilevel bool) ([]string, error) { if err := dgst.Validate(); err != nil { return nil, err diff --git a/registry/storage/schema2manifesthandler.go b/registry/storage/schema2manifesthandler.go index 3e32e9f4c..d9339403a 100644 --- a/registry/storage/schema2manifesthandler.go +++ b/registry/storage/schema2manifesthandler.go @@ -18,7 +18,7 @@ var ( errInvalidURL = errors.New("invalid URL on layer") ) -//schema2ManifestHandler is a ManifestHandler that covers schema2 manifests. +// schema2ManifestHandler is a ManifestHandler that covers schema2 manifests. type schema2ManifestHandler struct { repository distribution.Repository blobStore distribution.BlobStore diff --git a/version/print.go b/version/print.go index a82bce39f..318ac6953 100644 --- a/version/print.go +++ b/version/print.go @@ -9,13 +9,12 @@ import ( // FprintVersion outputs the version string to the writer, in the following // format, followed by a newline: // -// +// // // For example, a binary "registry" built from github.com/docker/distribution // with version "v2.0" would print the following: // -// registry github.com/docker/distribution v2.0 -// +// registry github.com/docker/distribution v2.0 func FprintVersion(w io.Writer) { fmt.Fprintln(w, os.Args[0], Package, Version) }