Skip to content

Modern Docker Management, Designed for Everyone

chore: fix linter

Kyle Mendell1967e03563e8
diff --git a/backend/internal/services/image_service.go b/backend/internal/services/image_service.go
index d3dea3d31..a338972b3 100644
--- a/backend/internal/services/image_service.go
+++ b/backend/internal/services/image_service.go
@@ -514,92 +514,97 @@ func buildUpdateMap(records []models.ImageUpdateRecord) map[string]*models.Image
return updateMap
}
+func parseRepoAndTagFromRepoTag(repoTag string) (repo, tag string) {
+ if named, err := ref.ParseNormalizedNamed(repoTag); err == nil {
+ repo = ref.FamiliarName(named)
+ if tagged, ok := named.(ref.NamedTagged); ok {
+ tag = tagged.Tag()
+ } else {
+ tag = "latest"
+ }
+ return repo, tag
+ }
+
+ if lastColonIdx := strings.LastIndex(repoTag, ":"); lastColonIdx != -1 {
+ return repoTag[:lastColonIdx], repoTag[lastColonIdx+1:]
+ }
+ return repoTag, "latest"
+}
+
+func parseRepoFromDigests(repoDigests []string) (repo string, found bool) {
+ for _, rd := range repoDigests {
+ if rd == "<none>@<none>" {
+ continue
+ }
+ if at := strings.LastIndex(rd, "@"); at != -1 {
+ candidateRepo := rd[:at]
+ if candidateRepo != "" {
+ return candidateRepo, true
+ }
+ }
+ }
+ return "", false
+}
+
+func determineRepoAndTag(di image.Summary) (repo, tag string) {
+ if len(di.RepoTags) > 0 {
+ return parseRepoAndTagFromRepoTag(di.RepoTags[0])
+ }
+
+ if len(di.RepoDigests) > 0 {
+ if r, found := parseRepoFromDigests(di.RepoDigests); found {
+ return r, "<none>"
+ }
+ }
+
+ return "<none>", "<none>"
+}
+
+func stringPtrValue(p *string) string {
+ if p == nil {
+ return ""
+ }
+ return *p
+}
+
+func buildUpdateInfo(updateRecord *models.ImageUpdateRecord) *dto.ImageUpdateInfoDto {
+ return &dto.ImageUpdateInfoDto{
+ HasUpdate: updateRecord.HasUpdate,
+ UpdateType: updateRecord.UpdateType,
+ CurrentVersion: updateRecord.CurrentVersion,
+ LatestVersion: stringPtrValue(updateRecord.LatestVersion),
+ CurrentDigest: stringPtrValue(updateRecord.CurrentDigest),
+ LatestDigest: stringPtrValue(updateRecord.LatestDigest),
+ CheckTime: updateRecord.CheckTime,
+ ResponseTimeMs: updateRecord.ResponseTimeMs,
+ Error: stringPtrValue(updateRecord.LastError),
+ AuthMethod: stringPtrValue(updateRecord.AuthMethod),
+ AuthUsername: stringPtrValue(updateRecord.AuthUsername),
+ AuthRegistry: stringPtrValue(updateRecord.AuthRegistry),
+ UsedCredential: updateRecord.UsedCredential,
+ }
+}
+
func mapDockerImagesToDTOs(dockerImages []image.Summary, inUseMap map[string]bool, updateMap map[string]*models.ImageUpdateRecord) []dto.ImageSummaryDto {
items := make([]dto.ImageSummaryDto, 0, len(dockerImages))
for _, di := range dockerImages {
- inUse := inUseMap[di.ID]
+ repo, tag := determineRepoAndTag(di)
imageDto := dto.ImageSummaryDto{
ID: di.ID,
+ Repo: repo,
+ Tag: tag,
RepoTags: di.RepoTags,
RepoDigests: di.RepoDigests,
Created: di.Created,
Size: di.Size,
VirtualSize: di.SharedSize,
Labels: convertLabels(di.Labels),
- InUse: inUse,
- }
-
- if len(di.RepoTags) > 0 {
- repoTag := di.RepoTags[0]
- // Use distribution/reference SDK to properly parse image references
- if named, err := ref.ParseNormalizedNamed(repoTag); err == nil {
- imageDto.Repo = ref.FamiliarName(named)
- if tagged, ok := named.(ref.NamedTagged); ok {
- imageDto.Tag = tagged.Tag()
- } else {
- imageDto.Tag = "latest"
- }
- } else {
- // Fallback for malformed references
- if lastColonIdx := strings.LastIndex(repoTag, ":"); lastColonIdx != -1 {
- imageDto.Repo = repoTag[:lastColonIdx]
- imageDto.Tag = repoTag[lastColonIdx+1:]
- } else {
- imageDto.Repo = repoTag
- imageDto.Tag = "latest"
- }
- }
- } else {
- // No RepoTags. If we have RepoDigests, derive repository from the part before '@'
- if len(di.RepoDigests) > 0 {
- for _, rd := range di.RepoDigests {
- if rd == "<none>@<none>" {
- continue
- }
- // Format: registry/path/name@sha256:...
- if at := strings.LastIndex(rd, "@"); at != -1 {
- candidateRepo := rd[:at]
- if candidateRepo != "" {
- imageDto.Repo = candidateRepo
- imageDto.Tag = "<none>"
- break
- }
- }
- }
- }
- // Fallbacks if no digest-derived repo found
- if imageDto.Repo == "" {
- imageDto.Repo = "<none>"
- }
- if imageDto.Tag == "" {
- imageDto.Tag = "<none>"
- }
+ InUse: inUseMap[di.ID],
}
if updateRecord, exists := updateMap[di.ID]; exists {
- sp := func(p *string) string {
- if p == nil {
- return ""
- }
- return *p
- }
-
- imageDto.UpdateInfo = &dto.ImageUpdateInfoDto{
- HasUpdate: updateRecord.HasUpdate,
- UpdateType: updateRecord.UpdateType,
- CurrentVersion: updateRecord.CurrentVersion,
- LatestVersion: sp(updateRecord.LatestVersion),
- CurrentDigest: sp(updateRecord.CurrentDigest),
- LatestDigest: sp(updateRecord.LatestDigest),
- CheckTime: updateRecord.CheckTime,
- ResponseTimeMs: updateRecord.ResponseTimeMs,
- Error: sp(updateRecord.LastError),
- AuthMethod: sp(updateRecord.AuthMethod),
- AuthUsername: sp(updateRecord.AuthUsername),
- AuthRegistry: sp(updateRecord.AuthRegistry),
- UsedCredential: updateRecord.UsedCredential,
- }
+ imageDto.UpdateInfo = buildUpdateInfo(updateRecord)
}
items = append(items, imageDto)
diff --git a/backend/internal/services/image_update_service.go b/backend/internal/services/image_update_service.go
index d65f697dc..55ed5c391 100644
--- a/backend/internal/services/image_update_service.go
+++ b/backend/internal/services/image_update_service.go
@@ -530,21 +530,8 @@ func (s *ImageUpdateService) saveUpdateResult(ctx context.Context, imageRef stri
return s.saveUpdateResultByID(ctx, imageID, result)
}
-func (s *ImageUpdateService) saveUpdateResultByID(ctx context.Context, imageID string, result *dto.ImageUpdateResponse) error {
- dockerClient, err := s.dockerService.CreateConnection(ctx)
- if err != nil {
- return fmt.Errorf("failed to connect to Docker: %w", err)
- }
- defer dockerClient.Close()
-
- dockerImage, err := dockerClient.ImageInspect(ctx, imageID)
- if err != nil {
- return fmt.Errorf("failed to inspect image: %w", err)
- }
-
- var repo, tag string
+func extractRepoAndTagFromImage(dockerImage image.InspectResponse) (repo, tag string) {
if len(dockerImage.RepoTags) > 0 && dockerImage.RepoTags[0] != "<none>:<none>" {
- // Use distribution/reference SDK for proper parsing
if named, err := ref.ParseNormalizedNamed(dockerImage.RepoTags[0]); err == nil {
repo = ref.FamiliarName(named)
if tagged, ok := named.(ref.NamedTagged); ok {
@@ -552,92 +539,83 @@ func (s *ImageUpdateService) saveUpdateResultByID(ctx context.Context, imageID s
} else {
tag = "latest"
}
+ return repo, tag
+ }
+
+ parts := strings.SplitN(dockerImage.RepoTags[0], ":", 2)
+ repo = parts[0]
+ if len(parts) > 1 {
+ tag = parts[1]
} else {
- // Fallback for malformed references
- parts := strings.SplitN(dockerImage.RepoTags[0], ":", 2)
- repo = parts[0]
- if len(parts) > 1 {
- tag = parts[1]
- } else {
- tag = "latest"
- }
+ tag = "latest"
}
- } else {
- // Attempt to derive repo from RepoDigests if available
- if len(dockerImage.RepoDigests) > 0 {
- for _, rd := range dockerImage.RepoDigests {
- if rd == "<none>@<none>" {
- continue
- }
- if at := strings.LastIndex(rd, "@"); at != -1 {
- repoCandidate := rd[:at]
- if repoCandidate != "" {
- repo = repoCandidate
- tag = "<none>"
- break
- }
+ return repo, tag
+ }
+
+ if len(dockerImage.RepoDigests) > 0 {
+ for _, rd := range dockerImage.RepoDigests {
+ if rd == "<none>@<none>" {
+ continue
+ }
+ if at := strings.LastIndex(rd, "@"); at != -1 {
+ repoCandidate := rd[:at]
+ if repoCandidate != "" {
+ return repoCandidate, "<none>"
}
}
}
- if repo == "" {
- repo = "<none>"
- }
- if tag == "" {
- tag = "<none>"
- }
}
- var lastError *string
- if result.Error != "" {
- lastError = &result.Error
- }
- var latestVersion *string
- if result.LatestVersion != "" {
- latestVersion = &result.LatestVersion
- }
- var currentDigest *string
- if result.CurrentDigest != "" {
- currentDigest = &result.CurrentDigest
- }
- var latestDigest *string
- if result.LatestDigest != "" {
- latestDigest = &result.LatestDigest
+ return "<none>", "<none>"
+}
+
+func stringToPtr(s string) *string {
+ if s == "" {
+ return nil
}
+ return &s
+}
+func buildImageUpdateRecord(imageID, repo, tag string, result *dto.ImageUpdateResponse) *models.ImageUpdateRecord {
currentVersion := result.CurrentVersion
if currentVersion == "" {
currentVersion = tag
}
- var authMethod, authUsername, authRegistry *string
- if result.AuthMethod != "" {
- authMethod = &result.AuthMethod
- }
- if result.AuthUsername != "" {
- authUsername = &result.AuthUsername
- }
- if result.AuthRegistry != "" {
- authRegistry = &result.AuthRegistry
- }
-
- updateRecord := &models.ImageUpdateRecord{
+ return &models.ImageUpdateRecord{
ID: imageID,
Repository: repo,
Tag: tag,
HasUpdate: result.HasUpdate,
UpdateType: result.UpdateType,
CurrentVersion: currentVersion,
- LatestVersion: latestVersion,
- CurrentDigest: currentDigest,
- LatestDigest: latestDigest,
+ LatestVersion: stringToPtr(result.LatestVersion),
+ CurrentDigest: stringToPtr(result.CurrentDigest),
+ LatestDigest: stringToPtr(result.LatestDigest),
CheckTime: result.CheckTime,
ResponseTimeMs: result.ResponseTimeMs,
- LastError: lastError,
- AuthMethod: authMethod,
- AuthUsername: authUsername,
- AuthRegistry: authRegistry,
+ LastError: stringToPtr(result.Error),
+ AuthMethod: stringToPtr(result.AuthMethod),
+ AuthUsername: stringToPtr(result.AuthUsername),
+ AuthRegistry: stringToPtr(result.AuthRegistry),
UsedCredential: result.UsedCredential,
}
+}
+
+func (s *ImageUpdateService) saveUpdateResultByID(ctx context.Context, imageID string, result *dto.ImageUpdateResponse) error {
+ dockerClient, err := s.dockerService.CreateConnection(ctx)
+ if err != nil {
+ return fmt.Errorf("failed to connect to Docker: %w", err)
+ }
+ defer dockerClient.Close()
+
+ dockerImage, err := dockerClient.ImageInspect(ctx, imageID)
+ if err != nil {
+ return fmt.Errorf("failed to inspect image: %w", err)
+ }
+
+ repo, tag := extractRepoAndTagFromImage(dockerImage)
+ updateRecord := buildImageUpdateRecord(imageID, repo, tag, result)
return s.db.WithContext(ctx).Save(updateRecord).Error
}