pypiURLParsed *url.URL
)
-func mkdirForPkg(w http.ResponseWriter, r *http.Request, dir string) bool {
- path := filepath.Join(*root, dir)
+func mkdirForPkg(w http.ResponseWriter, r *http.Request, pkgName string) bool {
+ path := filepath.Join(*root, pkgName)
if _, err := os.Stat(path); os.IsNotExist(err) {
if err = os.Mkdir(path, os.FileMode(0777)); err != nil {
+ log.Println("error", r.RemoteAddr, "mkdir", pkgName, err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return false
}
- log.Println(r.RemoteAddr, "mkdir", dir)
+ log.Println(r.RemoteAddr, "mkdir", pkgName)
}
return true
}
func listRoot(w http.ResponseWriter, r *http.Request) {
files, err := ioutil.ReadDir(*root)
if err != nil {
+ log.Println("error", r.RemoteAddr, "root", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
func listDir(
w http.ResponseWriter,
r *http.Request,
- dir string,
- autorefresh,
- gpgUpdate bool,
+ pkgName string,
+ autorefresh, gpgUpdate bool,
) {
- dirPath := filepath.Join(*root, dir)
+ dirPath := filepath.Join(*root, pkgName)
if autorefresh {
- if !refreshDir(w, r, dir, "", gpgUpdate) {
+ if !refreshDir(w, r, pkgName, "", gpgUpdate) {
return
}
- } else if _, err := os.Stat(dirPath); os.IsNotExist(err) && !refreshDir(w, r, dir, "", false) {
+ } else if _, err := os.Stat(dirPath); os.IsNotExist(err) && !refreshDir(w, r, pkgName, "", false) {
return
}
fis, err := ioutil.ReadDir(dirPath)
if err != nil {
+ log.Println("error", r.RemoteAddr, "list", pkgName, err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
files[fi.Name()] = struct{}{}
}
var result bytes.Buffer
- result.WriteString(fmt.Sprintf(HTMLBegin, dir))
+ result.WriteString(fmt.Sprintf(HTMLBegin, pkgName))
for _, algo := range knownHashAlgos {
for fn, _ := range files {
if killed {
delete(files, fn)
digest, err := ioutil.ReadFile(filepath.Join(dirPath, fn))
if err != nil {
+ log.Println("error", r.RemoteAddr, "list", fn, err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
result.WriteString(fmt.Sprintf(
HTMLElement,
strings.Join([]string{
- *refreshURLPath, dir, "/", fnClean,
+ *refreshURLPath, pkgName, "/", fnClean,
"#", algo, "=", hex.EncodeToString(digest),
}, ""),
gpgSigAttr,
w.Write(result.Bytes())
}
-func servePkg(w http.ResponseWriter, r *http.Request, dir, filename string) {
+func servePkg(w http.ResponseWriter, r *http.Request, pkgName, filename string) {
log.Println(r.RemoteAddr, "get", filename)
- path := filepath.Join(*root, dir, filename)
+ path := filepath.Join(*root, pkgName, filename)
if _, err := os.Stat(path); os.IsNotExist(err) {
- if !refreshDir(w, r, dir, filename, false) {
+ if !refreshDir(w, r, pkgName, filename, false) {
return
}
}
log.Fatalln(err)
}
refreshPasswd()
- log.Println("root:", *root, "bind:", *bind)
+ log.Println("root:", *root)
+ log.Println("bind:", *bind)
+ log.Println("pypi:", *pypiURL)
ln, err := net.Listen("tcp", *bind)
if err != nil {
signal.Notify(needsShutdown, syscall.SIGTERM, syscall.SIGINT)
go func() {
for range needsRefreshPasswd {
- log.Println("Refreshing passwords")
+ log.Println("refreshing passwords")
refreshPasswd()
}
}()
go func(s *http.Server) {
<-needsShutdown
killed = true
- log.Println("Shutting down")
+ log.Println("shutting down")
ctx, cancel := context.WithTimeout(context.TODO(), time.Minute)
exitErr <- s.Shutdown(ctx)
cancel()
log.Fatalf("%s:%d: %s: %s", *passwdPath, i, login, err)
}
passwordsNew[login] = auther
- log.Println("Added password for " + login)
+ log.Println("added password for " + login)
}
passwords = passwordsNew
}
func refreshDir(
w http.ResponseWriter,
r *http.Request,
- dir,
- filenameGet string,
+ pkgName, filenameGet string,
gpgUpdate bool,
) bool {
- if _, err := os.Stat(filepath.Join(*root, dir, InternalFlag)); err == nil {
+ if _, err := os.Stat(filepath.Join(*root, pkgName, InternalFlag)); err == nil {
return true
}
- resp, err := http.Get(*pypiURL + dir + "/")
+ resp, err := http.Get(*pypiURL + pkgName + "/")
if err != nil {
+ log.Println("error", r.RemoteAddr, "refresh", pkgName, err)
http.Error(w, err.Error(), http.StatusBadGateway)
return false
}
body, err := ioutil.ReadAll(resp.Body)
resp.Body.Close()
if err != nil {
+ log.Println("error", r.RemoteAddr, "refresh", pkgName, err)
http.Error(w, err.Error(), http.StatusBadGateway)
return false
}
- if !mkdirForPkg(w, r, dir) {
+ if !mkdirForPkg(w, r, pkgName) {
return false
}
- dirPath := filepath.Join(*root, dir)
+ dirPath := filepath.Join(*root, pkgName)
for _, lineRaw := range bytes.Split(body, []byte("\n")) {
submatches := pkgPyPI.FindStringSubmatch(string(lineRaw))
if len(submatches) == 0 {
filename := submatches[2]
pkgURL, err := url.Parse(uri)
if err != nil {
+ log.Println("error", r.RemoteAddr, "refresh", uri, err)
http.Error(w, err.Error(), http.StatusBadGateway)
return false
}
if pkgURL.Fragment == "" {
- log.Println(r.RemoteAddr, "pypi", filename, "no digest provided")
+ log.Println(r.RemoteAddr, "pypi", filename, "no digest")
http.Error(w, "no digest provided", http.StatusBadGateway)
return false
}
// Ancient non PEP-0503 PyPIs, assume MD5
digestInfo = []string{"md5", digestInfo[0]}
} else if len(digestInfo) != 2 {
- log.Println(r.RemoteAddr, "pypi", filename, "invalid digest provided")
+ log.Println("error", r.RemoteAddr, "pypi", filename, "invalid digest")
http.Error(w, "invalid digest provided", http.StatusBadGateway)
return false
}
digest, err := hex.DecodeString(digestInfo[1])
if err != nil {
+ log.Println("error", r.RemoteAddr, "pypi", filename, "invalid digest")
http.Error(w, err.Error(), http.StatusBadGateway)
return false
}
hasherNew = blake2b256New
hashSize = blake2b.Size256
default:
- log.Println(
- r.RemoteAddr, "pypi", filename,
- "unknown digest algorithm", hashAlgo,
- )
+ log.Println("error", r.RemoteAddr, "pypi", filename, "unknown digest", hashAlgo)
http.Error(w, "unknown digest algorithm", http.StatusBadGateway)
return false
}
if len(digest) != hashSize {
- log.Println(r.RemoteAddr, "pypi", filename, "invalid digest length")
+ log.Println("error", r.RemoteAddr, "pypi", filename, "invalid digest length")
http.Error(w, "invalid digest length", http.StatusBadGateway)
return false
}
http.Error(w, "shutting down", http.StatusInternalServerError)
return false
}
- log.Println(r.RemoteAddr, "pypi download", filename)
+ log.Println(r.RemoteAddr, "pypi", filename, "download")
resp, err = http.Get(uri)
if err != nil {
- log.Println(r.RemoteAddr, "pypi download error:", err.Error())
+ log.Println("error", r.RemoteAddr, "pypi", filename, "download", err)
http.Error(w, err.Error(), http.StatusBadGateway)
return false
}
hasherSHA256 := sha256.New()
dst, err := TempFile(dirPath)
if err != nil {
+ log.Println("error", r.RemoteAddr, "pypi", filename, err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return false
}
if _, err = io.Copy(wr, resp.Body); err != nil {
os.Remove(dst.Name())
dst.Close()
+ log.Println("error", r.RemoteAddr, "pypi", filename, err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return false
}
if err = dstBuf.Flush(); err != nil {
os.Remove(dst.Name())
dst.Close()
+ log.Println("error", r.RemoteAddr, "pypi", filename, err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return false
}
if err = dst.Sync(); err != nil {
os.Remove(dst.Name())
dst.Close()
+ log.Println("error", r.RemoteAddr, "pypi", filename, err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return false
}
if err = dst.Close(); err != nil {
+ log.Println("error", r.RemoteAddr, "pypi", filename, err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return false
}
if err = os.Rename(dst.Name(), path); err != nil {
+ log.Println("error", r.RemoteAddr, "pypi", filename, err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return false
}
if err = DirSync(dirPath); err != nil {
+ log.Println("error", r.RemoteAddr, "pypi", filename, err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return false
}
goto GPGSigSkip
}
if !bytes.HasPrefix(sig, []byte("-----BEGIN PGP SIGNATURE-----")) {
- log.Println(r.RemoteAddr, "pypi non PGP signature", filename)
+ log.Println(r.RemoteAddr, "pypi", filename+GPGSigExt, "non PGP")
goto GPGSigSkip
}
if err = WriteFileSync(dirPath, path+GPGSigExt, sig); err != nil {
+ log.Println("error", r.RemoteAddr, "pypi", filename+GPGSigExt, err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return false
}
- log.Println(r.RemoteAddr, "pypi downloaded signature", filename)
+ log.Println(r.RemoteAddr, "pypi", filename+GPGSigExt, "downloaded")
}
GPGSigSkip:
path = path + "." + hashAlgo
continue
}
if !os.IsNotExist(err) {
+ log.Println("error", r.RemoteAddr, "pypi", path, err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return false
}
- log.Println(r.RemoteAddr, "pypi touch", filename)
+ log.Println(r.RemoteAddr, "pypi", filename, "touch")
if err = WriteFileSync(dirPath, path, digest); err != nil {
+ log.Println("error", r.RemoteAddr, "pypi", path, err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return false
}
log.Println(r.RemoteAddr, "put", filename, "by", username)
path := filepath.Join(dirPath, filename)
if _, err = os.Stat(path); err == nil {
- log.Println(r.RemoteAddr, "already exists", filename)
+ log.Println(r.RemoteAddr, filename, "already exists")
http.Error(w, "already exists", http.StatusBadRequest)
return
}
src, err := file.Open()
defer src.Close()
if err != nil {
+ log.Println("error", r.RemoteAddr, filename, err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
dst, err := TempFile(dirPath)
if err != nil {
+ log.Println("error", r.RemoteAddr, filename, err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
hasher := sha256.New()
wr := io.MultiWriter(hasher, dst)
if _, err = io.Copy(wr, src); err != nil {
+ log.Println("error", r.RemoteAddr, filename, err)
os.Remove(dst.Name())
dst.Close()
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
if err = dstBuf.Flush(); err != nil {
+ log.Println("error", r.RemoteAddr, filename, err)
os.Remove(dst.Name())
dst.Close()
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
if err = dst.Sync(); err != nil {
+ log.Println("error", r.RemoteAddr, filename, err)
os.Remove(dst.Name())
dst.Close()
http.Error(w, err.Error(), http.StatusInternalServerError)
}
}
if err = os.Rename(dst.Name(), path); err != nil {
+ log.Println("error", r.RemoteAddr, path, err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
if err = DirSync(dirPath); err != nil {
+ log.Println("error", r.RemoteAddr, dirPath, err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
if err = WriteFileSync(dirPath, path+"."+HashAlgoSHA256, digest); err != nil {
+ log.Println("error", r.RemoteAddr, path+"."+HashAlgoSHA256, err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
for _, file := range r.MultipartForm.File["gpg_signature"] {
filename := file.Filename
if _, exists := gpgSigsExpected[filename]; !exists {
+ log.Println(r.RemoteAddr, filename, "unexpected GPG signature filename")
http.Error(w, "unexpected GPG signature filename", http.StatusBadRequest)
return
}
log.Println(r.RemoteAddr, "put", filename, "by", username)
path := filepath.Join(dirPath, filename)
if _, err = os.Stat(path); err == nil {
- log.Println(r.RemoteAddr, "already exists", filename)
+ log.Println(r.RemoteAddr, filename, "already exists")
http.Error(w, "already exists", http.StatusBadRequest)
return
}
src, err := file.Open()
if err != nil {
+ log.Println("error", r.RemoteAddr, filename, err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
sig, err := ioutil.ReadAll(src)
src.Close()
if err != nil {
+ log.Println("error", r.RemoteAddr, filename, err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
if err = WriteFileSync(dirPath, path, sig); err != nil {
+ log.Println("error", r.RemoteAddr, path, err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}