Please enable JavaScript.

Coggle requires JavaScript to display documents.

Docker-Distribution, app - Coggle Diagram

Docker-Distribution

registry/handlers/manifests.go
manifestHandler.GetManifest(http.Resp,http.Req)

Debug("GetImageManifest")
if tag != "" {
  digest=tags.Get(tag)
}
if digest == req.digest {
  return http.304 (Not Modified)
}
manifest=manifests.Get(digest)
ResponseWriter.Write(manifest)

registry/proxy/proxytagservcie.go
proxyTagService.Get(tag)

authChallenger
desc=remoteTags.Get(tag)
//localTags.Tag(tag,desc)
return desc

registry/proxy/proxymanifeststore.go
proxyManifestStore.Get(dgst)

authChallenger
manifest=remoteManifests.Get(dgst)
//localManifests.Put(manifest)
return manifest

registry/handlers/blob.go
blobHandler.GetBlob(http.Resp,http.Req)

Debug("GetBlob")
desc=blobs.Stat(digest)
if err !=nil return
blobs.ServerBlob(w,r,desc.Digest)

registry/proxy/proxyblobstore.go
proxyBlobStore.ServeBlob(w,r,dgst)

served=serveLocal(w,r,dgst)
if served return nil
authChallenger
mu.Lock()
ok=inflight[dgst]
if ok
  mu.Unlock()
  copyContent(dgst,w)
inflight[dgst]=struct{}{}
mu.Unlock()
go func(dgst){
 storeLocal(dgst)
}
copyContent(dgst,w)

registry/proxy/proxyblobstore.go
proxyBlobStore.serveLocal(w,r,dgst)

localDesc=localStore.Stat(dgst)
if err == nil {
 return true, localStore.ServeBlob(w,r,dgst)
}
return false, nil

registry/storage/blobserver.go
blobServer.ServeBlob(w,r,dgst)

desc=statter.Stat(dgst)
path=pathFn(desc.Digest)
if redirect {
 redirectURL=driver.URLFor(path)
 http.Redirect(w,r,redirectURL,307)
 return nil
}
reader=newFileReader(driver,path,size)
http.ServeContent(w,r,desc,xx,reader)
return nil

registry/proxy/proxyblobstore.go
proxyBlobStore.copyContent(dgst,w)

desc=remoteStore.Stat(dgst)
setResponseHeaders(w,desc.Size,dgst)
remoteReader=remoteStore.Open(dgst)
io.CopyN(w,remoteReader,desc.Size)
return desc,nil

registry/client/repository.go
blobs.Open(dgst)

blobURL=BuildBlobURL(ref)
return transport.NewHTTPReadSeeker(
  client,blobURL,func(resp)
)

registry/proxy/proxyblobstore.go
proxyBlobStore.storeLocal(dgst)

blobWriter=localStore.Create(ctx)
desc=copyContent(dgst, bw)
blobWriter.Commit(desc)
mu.Lock()
delete(inflight, dgst)
mu.Unlock()
return nil

registry/client/repository.go
blobs.Create(ctx)

url=BuildBlobUploadURL(blobs.name)
resp=client.Post(url,nil)
switch resp.StatusCode {
case http.StatusCreated:
  return nil, ErrExisted
case http.StatusAccepted:
  return &httpBlobUpload{xx}, nil
}

registry/storage/linkedblobstore.go
linkedBlobStore.Create(ctx)

Debug("(*linkedBlobStore).Writer")

registry/storage/registry.go
BlobDescriptorCacheProvider(cache)

statter=cache.NewCachedBlobStatter(...)
registry.blobStore.statter=statter
registry.blobServer.statter=statter

app

registry/handlers/app.go
NewApp(config)

app=&App{...}
app.register(...)
...
app.configureRedis(config)
...
cacheProvider=rediscache.New(app.redis)

registry/handlers/app.go
app.configureRedis(config)

pool=&redis.Pool{
 Dial: func() ...
 MaxIdle: ...
 Wait: false
}
app.redis=pool
...