sneak
a2a4d97f2f
check / check (push) Waiting to run
Without --base, check and freshen now look for a manifest's files in the directory that holds it, the file named or the one found in a directory argument, instead of the current directory. So `mfer check /media/drive` checks a drive against its own index.mf from anywhere. check of a manifest given by URL still uses the current directory, and --base still overrides, even when it names the current directory. The --base help text of both commands and the README's Tool Examples state the default; the README gains a freshen entry for this. Model: opus-5-5
106 lines
2.8 KiB
Go
106 lines
2.8 KiB
Go
package cli
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/urfave/cli/v3"
|
|
)
|
|
|
|
// manifestFetchTimeout bounds HTTP requests made to fetch a manifest.
|
|
const manifestFetchTimeout = 30 * time.Second
|
|
|
|
// errHTTPStatus indicates an HTTP response with a non-OK status code.
|
|
//
|
|
// Its text is the literal "HTTP" prefix of the rendered "HTTP <code>"
|
|
// message that mfer has always printed, so that wrapping it does not
|
|
// change any user-visible output. Match it with errors.Is; do not read
|
|
// its message.
|
|
var errHTTPStatus = errors.New("HTTP")
|
|
|
|
// errManifestTooLarge indicates a manifest download that passed
|
|
// CLIApp.maxManifestSize.
|
|
var errManifestTooLarge = errors.New("manifest exceeds maximum allowed size")
|
|
|
|
// isHTTPURL returns true if the string starts with http:// or https://.
|
|
func isHTTPURL(s string) bool {
|
|
return strings.HasPrefix(s, "http://") || strings.HasPrefix(s, "https://")
|
|
}
|
|
|
|
// openManifestReader opens a manifest from a path or URL and returns a ReadCloser.
|
|
// The caller must close the returned reader.
|
|
func (mfa *CLIApp) openManifestReader(
|
|
ctx context.Context, pathOrURL string,
|
|
) (io.ReadCloser, error) {
|
|
if isHTTPURL(pathOrURL) {
|
|
client := &http.Client{Timeout: manifestFetchTimeout}
|
|
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodGet, pathOrURL, nil)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to fetch %s: %w", pathOrURL, err)
|
|
}
|
|
|
|
resp, err := client.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to fetch %s: %w", pathOrURL, err)
|
|
}
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
_ = resp.Body.Close()
|
|
|
|
return nil, fmt.Errorf("failed to fetch %s: %w %d",
|
|
pathOrURL, errHTTPStatus, resp.StatusCode)
|
|
}
|
|
|
|
return resp.Body, nil
|
|
}
|
|
|
|
f, err := mfa.Fs.Open(pathOrURL)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return f, nil
|
|
}
|
|
|
|
// resolveManifestArg resolves the manifest path from CLI arguments.
|
|
// HTTP(S) URLs are returned as-is. Directories are searched for index.mf.
|
|
// If no argument is given, the current directory is searched.
|
|
func (mfa *CLIApp) resolveManifestArg(cmd *cli.Command) (string, error) {
|
|
if cmd.Args().Len() > 0 {
|
|
arg := cmd.Args().Get(0)
|
|
if isHTTPURL(arg) {
|
|
return arg, nil
|
|
}
|
|
|
|
info, statErr := mfa.Fs.Stat(arg)
|
|
if statErr == nil && info.IsDir() {
|
|
return findManifest(mfa.Fs, arg)
|
|
}
|
|
|
|
return arg, nil
|
|
}
|
|
|
|
return findManifest(mfa.Fs, ".")
|
|
}
|
|
|
|
// resolveBasePath returns the directory a manifest's paths are resolved
|
|
// against: the one --base names, or else the directory holding the manifest,
|
|
// or the current directory for a manifest URL.
|
|
func resolveBasePath(cmd *cli.Command, manifestPath string) string {
|
|
switch {
|
|
case cmd.IsSet(flagBase):
|
|
return cmd.String(flagBase)
|
|
case isHTTPURL(manifestPath):
|
|
return "."
|
|
default:
|
|
return filepath.Dir(manifestPath)
|
|
}
|
|
}
|