126 lines
3.9 KiB
Go
126 lines
3.9 KiB
Go
package common
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"net/url"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
)
|
|
|
|
func Validate(name string) error {
|
|
if name == "" {
|
|
return errors.New("name cannot be empty")
|
|
}
|
|
if strings.HasPrefix(name, "/") || strings.Contains(name, "\\") {
|
|
return errors.New("name must be a relative unix-style path")
|
|
}
|
|
if !strings.HasSuffix(name, ".git") {
|
|
return errors.New("name must end with .git")
|
|
}
|
|
parts := strings.Split(name, "/")
|
|
for _, part := range parts {
|
|
if part == "" || part == "." || part == ".." {
|
|
return errors.New("name contains an invalid path segment")
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func Resolve(root, name string) (string, error) {
|
|
if err := Validate(name); err != nil {
|
|
return "", err
|
|
}
|
|
full, err := filepath.Abs(filepath.Join(root, name))
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
absRoot, err := filepath.Abs(root)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if full != absRoot && !strings.HasPrefix(full, absRoot+string(os.PathSeparator)) {
|
|
return "", errors.New("repository path escapes root directory")
|
|
}
|
|
return full, nil
|
|
}
|
|
|
|
// splitOwnerName splits a smart-HTTP/SSH repo path "owner/name.git" into its
|
|
// IState (owner, name) form: both without the ".git" suffix. owner may itself
|
|
// contain "/" for nested namespaces (e.g. "org/team/name.git" -> owner
|
|
// "org/team", name "name"); name is always the final segment. IState
|
|
// reconstructs the on-disk path / DB full-name as owner+"/"+name+".git".
|
|
func SplitRepo(repo string) (owner, name string, err error) {
|
|
s := strings.TrimSuffix(repo, ".git")
|
|
i := strings.LastIndex(s, "/")
|
|
if i < 0 {
|
|
return "", "", errors.New("repository path must be owner/name.git")
|
|
}
|
|
return s[:i], s[i+1:], nil
|
|
}
|
|
|
|
// parseDBURI maps a URI scheme to (driver, dsn), following simpleconsole's
|
|
// ParseDBURI convention so the same URIs work across both services. Unexported:
|
|
// Open is the only entry point callers need.
|
|
//
|
|
// sqlite://<path>[?_pragma=...] -> driver "sqlite3", modernc DSN "file:<path>?..."
|
|
// postgres://<dsn-url> -> driver "postgres", dsn passed through verbatim
|
|
func ParseDBURI(root, uri string) (driver, dsn string, uriNew string, err error) {
|
|
if uri == "" {
|
|
return "", "", "", fmt.Errorf("database URI is empty")
|
|
}
|
|
scheme, rest, ok := splitScheme(uri)
|
|
if !ok {
|
|
return "", "", "", fmt.Errorf("database URI %q has no scheme (want sqlite:// or postgres://)", uri)
|
|
}
|
|
switch scheme {
|
|
case "sqlite", "sqlite3":
|
|
path, query, _ := strings.Cut(strings.TrimPrefix(rest, "//"), "?")
|
|
if path == "" {
|
|
return "", "", "", fmt.Errorf("sqlite URI %q has no file path", uri)
|
|
}
|
|
uriNew := "sqlite3://" + filepath.Join(root, path)
|
|
return "sqlite3", sqliteDSN(filepath.Join(root, path), query), uriNew, nil
|
|
case "postgres", "postgresql":
|
|
// lib/pq parses the URL form natively; pass it through unchanged.
|
|
return "postgres", uri, uri, nil
|
|
default:
|
|
return "", "", "", fmt.Errorf("unsupported database URI scheme %q (want sqlite:// or postgres://)", scheme)
|
|
}
|
|
}
|
|
|
|
// sqliteDSN builds a modernc DSN: "file:<path>?<params>". Default pragmas (WAL,
|
|
// busy_timeout, foreign_keys) and _txlock=immediate are applied only when the
|
|
// caller supplied no pragmas of their own; an explicit pragma set is respected
|
|
// verbatim.
|
|
func sqliteDSN(path, query string) string {
|
|
v, _ := url.ParseQuery(query)
|
|
if len(v["_pragma"]) == 0 {
|
|
v.Add("_pragma", "journal_mode(WAL)")
|
|
v.Add("_pragma", "busy_timeout(5000)")
|
|
v.Add("_pragma", "foreign_keys(ON)")
|
|
}
|
|
v.Add("_txlock", "immediate")
|
|
return "file:" + path + "?" + v.Encode()
|
|
}
|
|
|
|
// sqlitePath extracts the file path from a modernc DSN ("file:<path>?...").
|
|
func sqlitePath(dsn string) string {
|
|
s := strings.TrimPrefix(dsn, "file:")
|
|
if i := strings.Index(s, "?"); i >= 0 {
|
|
s = s[:i]
|
|
}
|
|
return s
|
|
}
|
|
|
|
// splitScheme splits "scheme:rest" at the first colon. ok is false when there
|
|
// is no colon.
|
|
func splitScheme(uri string) (scheme, rest string, ok bool) {
|
|
i := strings.Index(uri, ":")
|
|
if i < 0 {
|
|
return "", uri, false
|
|
}
|
|
return uri[:i], uri[i+1:], true
|
|
}
|