Merge pull request #9 from pubg/feature/tag-to-digest

Feature/tag to digest

remoteRegistry/docker/docker.go

@@ -112,27 +112,25 @@ func (d *RemoteRegistryDocker) getImageHighestVersionTag(url, tag, platformStrin
 	}
 
 	cacheKey := url + "___" + tag
-	target, err := d.cache.Get(cacheKey, func() (interface{}, error) {
+	image, err := d.cache.Get(cacheKey, func() (interface{}, error) {
 		tags, err := remote.List(repo, remote.WithAuthFromKeychain(authKeyChain))
 		if nil != err {
 			return "", err
 		}
 
-		tag, err := util.GetHighestVersionWithFilter(tags, tag)
+		t, err := util.GetHighestVersionWithFilter(tags, tag)
 		if nil != err {
 			return "", err
 		}
 
-		return d.getImageDigestHash(url, tag, platformString)
+		return d.getImageDigestHash(url, t, platformString)
 	})
 
 	if nil != err {
 		return "", err
 	}
 
-	fullUrl := fmt.Sprintf("%s:%s", url, target.(string))
-
-	return fullUrl, nil
+	return image.(string), nil
 }
 
 func (d *RemoteRegistryDocker) parsePlatform(platformString string) (*v1.Platform, error) {

remoteRegistry/docker/docker_test.go

@@ -0,0 +1,19 @@
+package docker
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestDocker(t *testing.T) {
+	r := NewRemoteRegistry()
+
+	if s, err := r.GetImageString("busybox", "1.34.*", "linux/amd64"); err != nil {
+		t.Fatalf("GetImageString asterisk err: %v", err)
+	} else if !strings.Contains(s, "@sha256:") {
+		t.Fatalf("GetImageString asterisk no digest: %s", s)
+	} else {
+		t.Logf("GetImageString asterisk success: %s", s)
+	}
+
+}

util/cache.go

@@ -8,40 +8,64 @@ import (
 type Cache struct {
 	TTL uint
 
-	cache map[string]cacheResult
-	mutex sync.Mutex
+	cache map[string]*cacheResult
+	mutex *sync.Mutex
 }
 
 type cacheResult struct {
 	value interface{}
 	err   error
 	time  time.Time
+	mutex *sync.Mutex
 }
 
 func NewCache(ttlSeconds uint) *Cache {
 	return &Cache{
 		TTL:   ttlSeconds,
-		cache: make(map[string]cacheResult),
+		cache: make(map[string]*cacheResult),
+		mutex: &sync.Mutex{},
 	}
 }
 
 func (c *Cache) Get(key string, getter func() (interface{}, error)) (interface{}, error) {
 	c.mutex.Lock()
-	defer c.mutex.Unlock()
+	cache, ok := c.cache[key]
+	c.mutex.Unlock()
 
-	if res, ok := c.cache[key]; ok && time.Since(res.time) < time.Duration(c.TTL)*time.Second {
-		return res.value, res.err
+	if ok && time.Since(cache.time) < time.Duration(c.TTL)*time.Second {
+		cache.mutex.Lock()
+		value, err := cache.value, cache.err
+		cache.mutex.Unlock()
+		return value, err
 	}
 
-	value, err := getter()
-	res := cacheResult{
-		value: value,
-		err:   err,
-		time:  time.Now(),
-	}
+	if ok {
+		cache.mutex.Lock()
+		value, err := getter() // getter 획득동안 lock 유지
+		cache.value = value
+		cache.err = err
+		cache.time = time.Now()
+		cache.mutex.Unlock()
+		return value, err
+	} else {
+		cache := &cacheResult{
+			value: nil,
+			err:   nil,
+			time:  time.Now(),
+			mutex: &sync.Mutex{},
+		}
+
+		c.mutex.Lock()
+		c.cache[key] = cache
+		c.mutex.Unlock()
 
-	c.cache[key] = res
-
-	return res.value, res.err
+		cache.mutex.Lock()
+		value, err := getter() // getter 획득동안 lock 유지
+		cache.value = value
+		cache.err = err
+		cache.time = time.Now()
+		cache.mutex.Unlock()
+		return value, err
+	}
 
 }

util/version.go

@@ -23,7 +23,7 @@ func GetHighestVersionWithFilter(versions []string, filter string) (string, erro
 		// fmt.Println(v)
 		matches := patt.FindStringSubmatch(v)
 
-		if 0 == len(matches) {
+		if len(matches) == 0 {
 			continue
 		}
 
@@ -32,14 +32,14 @@ func GetHighestVersionWithFilter(versions []string, filter string) (string, erro
 			continue
 		}
 
-		if targetVer >= ver {
+		if targetVer > ver {
 			continue
 		}
 
 		targetTag, targetVer = v, ver
 	}
 
-	if "" == targetTag {
+	if targetTag == "" {
 		return "", ERR_NOT_FOUND
 	}