func (n ACFullname) LatestVersion() (string, error) {
app, err := discovery.NewAppFromString(n.Name() + ":latest")
if app.Labels["os"] == "" {
app.Labels["os"] = "linux"
}
if app.Labels["arch"] == "" {
app.Labels["arch"] = "amd64"
}
endpoints, _, err := discovery.DiscoverACIEndpoints(*app, nil, discovery.InsecureTLS|discovery.InsecureHTTP) //TODO support security
if err != nil {
return "", errors.Annotate(err, "Latest discovery fail")
}
r, _ := regexp.Compile(`^\d+(.\d+){0,2}(-[\.\-\dA-Za-z]+){0,1}$`) // TODO this is nexus specific
if len(endpoints) == 0 {
return "", errs.WithF(data.WithField("aci", string(n)), "Discovery does not give an endpoint to check latest version")
}
url := getRedirectForLatest(endpoints[0].ACI)
logs.WithField("url", url).Debug("latest verion url")
for _, part := range strings.Split(url, "/") {
if r.Match([]byte(part)) {
return part, nil
}
}
return "", errors.New("No latest version found")
}
func discoverACI(app discovery.App, asc *os.File) (*os.File, *os.File, error) {
var aci *os.File
// TODO: hostHeaders, insecure
if eps, _, err := discovery.DiscoverACIEndpoints(app, nil, 0); err != nil {
return nil, nil, err
} else {
var err error
if asc == nil {
err = nil
for _, ep := range eps {
if af, er1 := OpenLocation(ep.ASC); er1 != nil {
err = multierror.Append(err, er1)
} else {
asc = af
break
}
}
if err != nil {
return nil, nil, err
}
}
err = nil
for _, ep := range eps {
if af, er1 := OpenLocation(ep.ACI); er1 != nil {
err = multierror.Append(err, er1)
} else {
aci = af
break
}
if aci == nil {
if asc != nil {
asc.Close()
}
return nil, nil, err
}
}
return aci, asc, nil
}
}
func (r Registry) discoverEndpoint(imageName types.ACIdentifier, labels types.Labels) (*discovery.ACIEndpoint, error) {
labelmap := make(map[types.ACIdentifier]string)
for _, label := range labels {
labelmap[label.Name] = label.Value
}
app, err := discovery.NewApp(string(imageName), labelmap)
if err != nil {
return nil, err
}
if _, ok := app.Labels["arch"]; !ok {
app.Labels["arch"] = runtime.GOARCH
}
if _, ok := app.Labels["os"]; !ok {
app.Labels["os"] = runtime.GOOS
}
insecure := discovery.InsecureNone
if r.Insecure {
insecure = discovery.InsecureHTTP
}
acis, attempts, err := discovery.DiscoverACIEndpoints(*app, nil, insecure)
if err != nil {
return nil, err
}
if r.Debug {
for _, a := range attempts {
fmt.Fprintf(os.Stderr, "meta tag not found on %s: %v\n",
a.Prefix, a.Error)
}
}
if len(acis) == 0 {
return nil, fmt.Errorf("no endpoints discovered to download %s",
imageName)
}
return &acis[0], nil
}
func (f *nameFetcher) discoverApp(app *discovery.App) (discovery.ACIEndpoints, error) {
insecure := discovery.InsecureNone
if f.InsecureFlags.SkipTLSCheck() {
insecure = insecure | discovery.InsecureTLS
}
if f.InsecureFlags.AllowHTTP() {
insecure = insecure | discovery.InsecureHTTP
}
hostHeaders := config.ResolveAuthPerHost(f.Headers)
ep, attempts, err := discovery.DiscoverACIEndpoints(*app, hostHeaders, insecure, 0)
if f.Debug {
for _, a := range attempts {
log.PrintE(fmt.Sprintf("meta tag 'ac-discovery' not found on %s", a.Prefix), a.Error)
}
}
if err != nil {
return nil, err
}
if len(ep) == 0 {
return nil, fmt.Errorf("no endpoints discovered")
}
return ep, nil
}
func runDiscover(args []string) (exit int) {
if len(args) < 1 {
stderr("discover: at least one name required")
}
for _, name := range args {
app, err := discovery.NewAppFromString(name)
if app.Labels["os"] == "" {
app.Labels["os"] = runtime.GOOS
}
if app.Labels["arch"] == "" {
app.Labels["arch"] = runtime.GOARCH
}
if err != nil {
stderr("%s: %s", name, err)
return 1
}
insecure := discovery.InsecureNone
if transportFlags.Insecure {
insecure = discovery.InsecureTLS | discovery.InsecureHTTP
}
eps, attempts, err := discovery.DiscoverACIEndpoints(*app, nil, insecure)
if err != nil {
stderr("error fetching endpoints for %s: %s", name, err)
return 1
}
for _, a := range attempts {
fmt.Printf("discover endpoints walk: prefix: %s error: %v\n", a.Prefix, a.Error)
}
publicKeys, attempts, err := discovery.DiscoverPublicKeys(*app, nil, insecure)
if err != nil {
stderr("error fetching public keys for %s: %s", name, err)
return 1
}
for _, a := range attempts {
fmt.Printf("discover public keys walk: prefix: %s error: %v\n", a.Prefix, a.Error)
}
type discoveryData struct {
ACIEndpoints []discovery.ACIEndpoint
PublicKeys []string
}
if outputJson {
dd := discoveryData{ACIEndpoints: eps, PublicKeys: publicKeys}
jsonBytes, err := json.MarshalIndent(dd, "", " ")
if err != nil {
stderr("error generating JSON: %s", err)
return 1
}
fmt.Println(string(jsonBytes))
} else {
for _, aciEndpoint := range eps {
fmt.Printf("ACI: %s, ASC: %s\n", aciEndpoint.ACI, aciEndpoint.ASC)
}
if len(publicKeys) > 0 {
fmt.Println("PublicKeys: " + strings.Join(publicKeys, ","))
}
}
}
return
}