Check that the directory exists before applying operations.

This yields some nicer error messages rather than letting the failure
manifest somewhere down the line, e.g., from lock timeouts.

Author: LTLA

create.go

@@ -57,6 +57,9 @@ func createProject(project string, inperms *unsafePermissionsMetadata, req_user
 
     // No need to lock before MkdirAll, it just no-ops if the directory already exists.
     err = os.MkdirAll(project_dir, 0755)
+    if err != nil {
+        return fmt.Errorf("failed to create a new project directory for %s; %w", project, err)
+    }
 
     globals.Locks.LockDirectory(project_dir, 10 * time.Second)
     if err != nil {

latest.go

@@ -120,16 +120,26 @@ func refreshLatestHandler(reqpath string, globals *globalConfiguration) (*latest
         }
     }
 
+    project := *(incoming.Project)
+    project_dir := filepath.Join(globals.Registry, project)
+    if err := checkProjectExists(project_dir, project); err != nil {
+        return nil, err
+    }
+
     // Technically we only need a lock on the asset directory, but all
     // mutating operations will lock the project directory, so we respect that.
-    project_dir := filepath.Join(globals.Registry, *(incoming.Project))
     err = globals.Locks.LockDirectory(project_dir, 10 * time.Second)
     if err != nil {
         return nil, fmt.Errorf("failed to acquire the lock on the project directory %q; %w", project_dir, err)
     }
     defer globals.Locks.Unlock(project_dir)
 
-    asset_dir := filepath.Join(project_dir, *(incoming.Asset))
+    asset := *(incoming.Asset)
+    asset_dir := filepath.Join(project_dir, asset)
+    if err := checkAssetExists(asset_dir, asset, project); err != nil {
+        return nil, err
+    }
+
     output, err := refreshLatest(asset_dir)
     return output, err
 }

permissions.go

@@ -221,6 +221,10 @@ func setPermissionsHandler(reqpath string, globals *globalConfiguration) error {
 
     project := *(incoming.Project)
     project_dir := filepath.Join(globals.Registry, project)
+    if err := checkProjectExists(project_dir, project); err != nil {
+        return err
+    }
+
     err = globals.Locks.LockDirectory(project_dir, 10 * time.Second)
     if err != nil {
         return fmt.Errorf("failed to lock project directory %q; %w", project_dir, err)

probation.go

@@ -50,6 +50,10 @@ func baseProbationHandler(reqpath string, globals *globalConfiguration, approve
 
     project := *(incoming.Project)
     project_dir := filepath.Join(globals.Registry, project)
+    if err := checkProjectExists(project_dir, project); err != nil {
+        return err
+    }
+
     err = globals.Locks.LockDirectory(project_dir, 10 * time.Second)
     if err != nil {
         return fmt.Errorf("failed to lock project directory %q; %w", project_dir, err)
@@ -64,8 +68,18 @@ func baseProbationHandler(reqpath string, globals *globalConfiguration, approve
         return newHttpError(http.StatusForbidden, fmt.Errorf("user %q is not authorized to modify probation status in %q", username, project_dir))
     }
 
-    asset_dir := filepath.Join(project_dir, *(incoming.Asset))
-    version_dir := filepath.Join(asset_dir, *(incoming.Version))
+    asset := *(incoming.Asset)
+    asset_dir := filepath.Join(project_dir, asset)
+    if err := checkAssetExists(asset_dir, asset, project); err != nil {
+        return err
+    }
+
+    version := *(incoming.Version)
+    version_dir := filepath.Join(asset_dir, version)
+    if err := checkVersionExists(version_dir, version, asset, project); err != nil {
+        return err
+    }
+
     summ, err := readSummary(version_dir)
     if err != nil {
         return fmt.Errorf("failed to read the version summary at %q; %w", version_dir, err)
@@ -120,8 +134,8 @@ func baseProbationHandler(reqpath string, globals *globalConfiguration, approve
         log_info := map[string]interface{} {
             "type": "add-version",
             "project": project,
-            "asset": *(incoming.Asset),
-            "version": *(incoming.Version),
+            "asset": asset,
+            "version": version,
             "latest": overwrite_latest,
         }
         err = dumpLog(globals.Registry, &log_info)

reindex.go

@@ -74,6 +74,10 @@ func reindexHandler(reqpath string, globals *globalConfiguration) error {
     // Configuring the project; we apply a lock to the project to avoid concurrent changes.
     project := *(request.Project)
     project_dir := filepath.Join(globals.Registry, project)
+    if err := checkProjectExists(project_dir, project); err != nil {
+        return err
+    }
+
     err = globals.Locks.LockDirectory(project_dir, 10 * time.Second)
     if err != nil {
         return fmt.Errorf("failed to acquire the lock on %q; %w", project_dir, err)
@@ -94,14 +98,14 @@ func reindexHandler(reqpath string, globals *globalConfiguration) error {
     // Configuring the asset and version.
     asset := *(request.Asset)
     asset_dir := filepath.Join(project_dir, asset)
-    if _, err := os.Stat(asset_dir); err != nil {
-        return newHttpError(http.StatusNotFound, fmt.Errorf("cannot access asset directory at %q; %w", asset_dir, err))
+    if err := checkAssetExists(asset_dir, asset, project); err != nil {
+        return err
     }
 
     version := *(request.Version)
     version_dir := filepath.Join(asset_dir, version)
-    if _, err := os.Stat(version_dir); err != nil {
-        return newHttpError(http.StatusNotFound, fmt.Errorf("cannot access version directory at %q; %w", asset_dir, err))
+    if err := checkVersionExists(version_dir, version, asset, project); err != nil {
+        return err
     }
 
     err = reindexDirectory(globals.Registry, project, asset, version)

upload.go

@@ -98,6 +98,10 @@ func uploadHandler(reqpath string, globals *globalConfiguration) error {
     // Configuring the project; we apply a lock to the project to avoid concurrent changes.
     project := *(request.Project)
     project_dir := filepath.Join(globals.Registry, project)
+    if err := checkProjectExists(project_dir, project); err != nil {
+        return err
+    }
+
     err = globals.Locks.LockDirectory(project_dir, 10 * time.Second)
     if err != nil {
         return fmt.Errorf("failed to acquire the lock on %q; %w", project_dir, err)

usage.go

@@ -108,7 +108,12 @@ func refreshUsageHandler(reqpath string, globals *globalConfiguration) (*usageMe
         }
     }
 
-    project_dir := filepath.Join(globals.Registry, *(incoming.Project))
+    project := *(incoming.Project)
+    project_dir := filepath.Join(globals.Registry, project)
+    if err := checkProjectExists(project_dir, project); err != nil {
+        return nil, err
+    }
+
     err = globals.Locks.LockDirectory(project_dir, 10 * time.Second)
     if err != nil {
         return nil, fmt.Errorf("failed to lock the project directory %q; %w", project_dir, err)

utils.go

@@ -10,6 +10,7 @@ import (
     "math/rand"
     "strconv"
     "path/filepath"
+    "net/http"
 )
 
 type globalConfiguration struct {
@@ -114,3 +115,36 @@ func dumpLog(registry string, content interface{}) error {
     path := time.Now().Format(time.RFC3339) + "_" + strconv.Itoa(100000 + rand.Intn(900000))
     return dumpJson(filepath.Join(registry, logDirName, path), content)
 }
+
+func checkProjectExists(project_dir, project string) error {
+    _, err := os.Stat(project_dir) 
+    if errors.Is(err, os.ErrNotExist) {
+        return newHttpError(http.StatusNotFound, fmt.Errorf("project %s does not exist", project))
+    } else if err != nil {
+        return fmt.Errorf("failed to stat %q; %w", project_dir, err)
+    } else {
+        return nil
+    }
+}
+
+func checkAssetExists(asset_dir, asset, project string) error {
+    _, err := os.Stat(asset_dir) 
+    if errors.Is(err, os.ErrNotExist) {
+        return newHttpError(http.StatusNotFound, fmt.Errorf("asset %s does not exist in project %s", asset, project))
+    } else if err != nil {
+        return fmt.Errorf("failed to stat %q; %w", asset_dir, err)
+    } else {
+        return nil
+    }
+}
+
+func checkVersionExists(version_dir, version, asset, project string) error {
+    _, err := os.Stat(version_dir)
+    if errors.Is(err, os.ErrNotExist) {
+        return newHttpError(http.StatusNotFound, fmt.Errorf("version %s does not exist for asset %s of project %s", version, asset, project))
+    } else if err != nil {
+        return fmt.Errorf("failed to stat %q; %w", version_dir, err)
+    } else {
+        return nil
+    }
+}

utils_test.go

@@ -7,6 +7,8 @@ import (
     "fmt"
     "path/filepath"
     "encoding/json"
+    "errors"
+    "net/http"
 )
 
 func dumpRequest(request_type, request_string string) (string, error) {
@@ -109,3 +111,63 @@ func TestIsBadName(t *testing.T) {
         t.Fatal("failed to stop in the presence of a backslash")
     }
 }
+
+func TestCheckProjectExists(t *testing.T) {
+    reg, err := os.MkdirTemp("", "")
+    if err != nil {
+        t.Fatal(err)
+    }
+
+    err = checkProjectExists(filepath.Join(reg, "doesnt_exist"), "foo")
+    var http_err *httpError
+    if !errors.As(err, &http_err) {
+        t.Error("expected a HTTP error")
+    } else if http_err.Status != http.StatusNotFound {
+        t.Error("expected a HTTP error with a 404")
+    }
+
+    err = checkProjectExists(reg, "foo")
+    if err != nil {
+        t.Error("no error expected here")
+    }
+}
+
+func TestCheckAssetExists(t *testing.T) {
+    reg, err := os.MkdirTemp("", "")
+    if err != nil {
+        t.Fatal(err)
+    }
+
+    err = checkAssetExists(filepath.Join(reg, "doesnt_exist"), "bar", "foo")
+    var http_err *httpError
+    if !errors.As(err, &http_err) {
+        t.Error("expected a HTTP error")
+    } else if http_err.Status != http.StatusNotFound {
+        t.Error("expected a HTTP error with a 404")
+    }
+
+    err = checkAssetExists(reg, "bar", "foo")
+    if err != nil {
+        t.Error("no error expected here")
+    }
+}
+
+func TestCheckVersionExists(t *testing.T) {
+    reg, err := os.MkdirTemp("", "")
+    if err != nil {
+        t.Fatal(err)
+    }
+
+    err = checkVersionExists(filepath.Join(reg, "doesnt_exist"), "whee", "bar", "foo")
+    var http_err *httpError
+    if !errors.As(err, &http_err) {
+        t.Error("expected a HTTP error")
+    } else if http_err.Status != http.StatusNotFound {
+        t.Error("expected a HTTP error with a 404")
+    }
+
+    err = checkVersionExists(reg, "whee", "bar", "foo")
+    if err != nil {
+        t.Error("no error expected here")
+    }
+}