func serveHRPkg(w http.ResponseWriter, r *http.Request) {
cols := strings.Split(strings.TrimRight(r.URL.Path, "/"), "/")
pkgName := cols[len(cols)-1]
- meta, releases, err := getMetadata(pkgName, "")
+ meta, releases, err := getMD(pkgName, "")
if err != nil {
if os.IsNotExist(err) {
http.NotFound(w, r)
"go.cypherpunks.ru/recfile"
)
-func getMetadata(pkgName, version string) (*PkgMeta, []*PkgReleaseInfo, error) {
+func getMD(pkgName, version string) (*PkgMeta, []*PkgReleaseInfo, error) {
serial, releases, err := listDir(pkgName, true)
if err != nil {
return nil, nil, err
}
- metadata, err := ioutil.ReadFile(filepath.Join(Root, pkgName, MetadataFile))
+ md, err := ioutil.ReadFile(filepath.Join(Root, pkgName, MDFile))
if err != nil {
if !os.IsNotExist(err) {
return nil, nil, err
}
}
info := PkgInfo{Name: pkgName}
- if len(metadata) == 0 {
+ if len(md) == 0 {
info.Version = releases[len(releases)-1].Version
} else {
- m, err := recfile.NewReader(bytes.NewReader(metadata)).NextMapWithSlice()
+ m, err := recfile.NewReader(bytes.NewReader(md)).NextMapWithSlice()
if err != nil {
return nil, nil, err
}
- if v, ok := m[metadataFieldToRecField(MetadataFieldVersion)]; ok {
+ if v, ok := m[MDFieldToRecField[MDFieldVersion]]; ok {
info.Version = v[0]
}
- if v, ok := m[metadataFieldToRecField(MetadataFieldSummary)]; ok {
+ if v, ok := m[MDFieldToRecField[MDFieldSummary]]; ok {
info.Summary = v[0]
}
- if v, ok := m[metadataFieldToRecField(MetadataFieldDescriptionContentType)]; ok {
+ if v, ok := m[MDFieldToRecField[MDFieldDescriptionContentType]]; ok {
info.DescriptionContentType = v[0]
}
- if v, ok := m[metadataFieldToRecField(MetadataFieldKeywords)]; ok {
+ if v, ok := m[MDFieldToRecField[MDFieldKeywords]]; ok {
info.Keywords = v[0]
}
- if v, ok := m[metadataFieldToRecField(MetadataFieldHomePage)]; ok {
+ if v, ok := m[MDFieldToRecField[MDFieldHomePage]]; ok {
info.HomePage = v[0]
}
- if v, ok := m[metadataFieldToRecField(MetadataFieldAuthor)]; ok {
+ if v, ok := m[MDFieldToRecField[MDFieldAuthor]]; ok {
info.Author = v[0]
}
- if v, ok := m[metadataFieldToRecField(MetadataFieldAuthorEmail)]; ok {
+ if v, ok := m[MDFieldToRecField[MDFieldAuthorEmail]]; ok {
info.AuthorEmail = v[0]
}
- if v, ok := m[metadataFieldToRecField(MetadataFieldMaintainer)]; ok {
+ if v, ok := m[MDFieldToRecField[MDFieldMaintainer]]; ok {
info.Maintainer = v[0]
}
- if v, ok := m[metadataFieldToRecField(MetadataFieldMaintainerEmail)]; ok {
+ if v, ok := m[MDFieldToRecField[MDFieldMaintainerEmail]]; ok {
info.MaintainerEmail = v[0]
}
- if v, ok := m[metadataFieldToRecField(MetadataFieldLicense)]; ok {
+ if v, ok := m[MDFieldToRecField[MDFieldLicense]]; ok {
info.License = v[0]
}
- if v, ok := m[metadataFieldToRecField(MetadataFieldRequiresPython)]; ok {
+ if v, ok := m[MDFieldToRecField[MDFieldRequiresPython]]; ok {
info.RequiresPython = v[0]
}
- if v, ok := m[metadataFieldToRecField(MetadataFieldDescription)]; ok {
+ if v, ok := m[MDFieldToRecField[MDFieldDescription]]; ok {
info.Description = v[0]
}
- info.Classifier = m[metadataFieldToRecField(MetadataFieldClassifier)]
- info.Platform = m[metadataFieldToRecField(MetadataFieldPlatform)]
- info.SupportedPlatform = m[metadataFieldToRecField(MetadataFieldSupportedPlatform)]
- info.RequiresDist = m[metadataFieldToRecField(MetadataFieldRequiresDist)]
- info.RequiresExternal = m[metadataFieldToRecField(MetadataFieldRequiresExternal)]
- info.ProjectURL = m[metadataFieldToRecField(MetadataFieldProjectURL)]
- info.ProvidesExtra = m[metadataFieldToRecField(MetadataFieldProvidesExtra)]
+ info.Classifier = m[MDFieldToRecField[MDFieldClassifier]]
+ info.Platform = m[MDFieldToRecField[MDFieldPlatform]]
+ info.SupportedPlatform = m[MDFieldToRecField[MDFieldSupportedPlatform]]
+ info.RequiresDist = m[MDFieldToRecField[MDFieldRequiresDist]]
+ info.RequiresExternal = m[MDFieldToRecField[MDFieldRequiresExternal]]
+ info.ProjectURL = m[MDFieldToRecField[MDFieldProjectURL]]
+ info.ProvidesExtra = m[MDFieldToRecField[MDFieldProvidesExtra]]
}
meta := PkgMeta{
Info: info,
}
pkgName := parts[0]
- meta, _, err := getMetadata(pkgName, version)
+ meta, _, err := getMD(pkgName, version)
if err != nil {
if os.IsNotExist(err) {
http.NotFound(w, r)
return 0, nil, err
}
serial := fi.ModTime().Unix()
- if fi, err = os.Stat(filepath.Join(dirPath, MetadataFile)); err == nil {
+ if fi, err = os.Stat(filepath.Join(dirPath, MDFile)); err == nil {
serial += fi.ModTime().Unix()
}
return serial, releases, nil
)
const (
- Version = "3.2.0"
+ Version = "3.3.0"
UserAgent = "GoCheese/" + Version
)
package main
-import "strings"
-
const (
- MetadataFile = ".metadata.rec"
+ MDFile = ".metadata.rec"
// https://packaging.python.org/specifications/core-metadata/
- MetadataVersion = "2.1"
- MetadataFieldMetadataVersion = "Metadata-Version"
- MetadataFieldName = "Name"
- MetadataFieldVersion = "Version"
- MetadataFieldDescription = "Description"
- MetadataFieldPlatform = "Platform"
- MetadataFieldSupportedPlatform = "Supported-Platform"
- MetadataFieldSummary = "Summary"
- MetadataFieldDescriptionContentType = "Description-Content-Type"
- MetadataFieldKeywords = "Keywords"
- MetadataFieldHomePage = "Home-page"
- MetadataFieldAuthor = "Author"
- MetadataFieldAuthorEmail = "Author-email"
- MetadataFieldMaintainer = "Maintainer"
- MetadataFieldMaintainerEmail = "Maintainer-Email"
- MetadataFieldLicense = "License"
- MetadataFieldRequiresDist = "Requires-Dist"
- MetadataFieldRequiresPython = "Requires-Python"
- MetadataFieldRequiresExternal = "Requires-External"
- MetadataFieldProjectURL = "Project-URL"
- MetadataFieldProvidesExtra = "Provides-Extra"
- MetadataFieldClassifier = "Classifier"
+ MDVersion = "2.1"
+ MDFieldMetadataVersion = "Metadata-Version"
+ MDFieldName = "Name"
+ MDFieldVersion = "Version"
+ MDFieldDescription = "Description"
+ MDFieldPlatform = "Platform"
+ MDFieldSupportedPlatform = "Supported-Platform"
+ MDFieldSummary = "Summary"
+ MDFieldDescriptionContentType = "Description-Content-Type"
+ MDFieldKeywords = "Keywords"
+ MDFieldHomePage = "Home-page"
+ MDFieldAuthor = "Author"
+ MDFieldAuthorEmail = "Author-email"
+ MDFieldMaintainer = "Maintainer"
+ MDFieldMaintainerEmail = "Maintainer-email"
+ MDFieldLicense = "License"
+ MDFieldRequiresDist = "Requires-Dist"
+ MDFieldRequiresPython = "Requires-Python"
+ MDFieldRequiresExternal = "Requires-External"
+ MDFieldProjectURL = "Project-URL"
+ MDFieldProvidesExtra = "Provides-Extra"
+ MDFieldClassifier = "Classifier"
)
-func metadataFieldToRecField(f string) string {
- return strings.ReplaceAll(f, "-", "")
-}
+var (
+ MDFieldToRecField = map[string]string{
+ MDFieldMetadataVersion: "MetadataVersion",
+ MDFieldName: "Name",
+ MDFieldVersion: "Version",
+ MDFieldDescription: "Description",
+ MDFieldPlatform: "Platform",
+ MDFieldSupportedPlatform: "SupportedPlatform",
+ MDFieldSummary: "Summary",
+ MDFieldDescriptionContentType: "DescriptionContentType",
+ MDFieldKeywords: "Keywords",
+ MDFieldHomePage: "HomePage",
+ MDFieldAuthor: "Author",
+ MDFieldAuthorEmail: "AuthorEmail",
+ MDFieldMaintainer: "Maintainer",
+ MDFieldMaintainerEmail: "MaintainerEmail",
+ MDFieldLicense: "License",
+ MDFieldRequiresDist: "RequiresDist",
+ MDFieldRequiresPython: "RequiresPython",
+ MDFieldRequiresExternal: "RequiresExternal",
+ MDFieldProjectURL: "ProjectURL",
+ MDFieldProvidesExtra: "ProvidesExtra",
+ MDFieldClassifier: "Classifier",
+ }
+ MDFormToRecField = [][2]string{
+ {"name", MDFieldToRecField[MDFieldName]},
+ {"version", MDFieldToRecField[MDFieldVersion]},
+ {"platform", MDFieldToRecField[MDFieldPlatform]},
+ {"supported_platform", MDFieldToRecField[MDFieldSupportedPlatform]},
+ {"summary", MDFieldToRecField[MDFieldSummary]},
+ {"description", MDFieldToRecField[MDFieldDescription]},
+ {"description_content_type", MDFieldToRecField[MDFieldDescriptionContentType]},
+ {"keywords", MDFieldToRecField[MDFieldKeywords]},
+ {"home_page", MDFieldToRecField[MDFieldHomePage]},
+ {"author", MDFieldToRecField[MDFieldAuthor]},
+ {"author_email", MDFieldToRecField[MDFieldAuthorEmail]},
+ {"maintainer", MDFieldToRecField[MDFieldMaintainer]},
+ {"maintainer_email", MDFieldToRecField[MDFieldMaintainerEmail]},
+ {"license", MDFieldToRecField[MDFieldLicense]},
+ {"classifiers", MDFieldToRecField[MDFieldClassifier]},
+ {"requires_dist", MDFieldToRecField[MDFieldRequiresDist]},
+ {"requires_python", MDFieldToRecField[MDFieldRequiresPython]},
+ {"requires_external", MDFieldToRecField[MDFieldRequiresExternal]},
+ {"project_url", MDFieldToRecField[MDFieldProjectURL]},
+ {"provides_extra", MDFieldToRecField[MDFieldProvidesExtra]},
+ }
+)
// It should follow https://www.python.org/dev/peps/pep-0566/
type PkgInfo struct {
err = json.Unmarshal(body, &meta)
if err == nil {
for _, m := range [][2]string{
- {MetadataFieldName, meta.Info.Name},
- {MetadataFieldVersion, meta.Info.Version},
- {MetadataFieldSummary, meta.Info.Summary},
- {MetadataFieldDescriptionContentType, meta.Info.DescriptionContentType},
- {MetadataFieldKeywords, meta.Info.Keywords},
- {MetadataFieldHomePage, meta.Info.HomePage},
- {MetadataFieldAuthor, meta.Info.Author},
- {MetadataFieldAuthorEmail, meta.Info.AuthorEmail},
- {MetadataFieldMaintainer, meta.Info.Maintainer},
- {MetadataFieldMaintainerEmail, meta.Info.MaintainerEmail},
- {MetadataFieldLicense, meta.Info.License},
- {MetadataFieldRequiresPython, meta.Info.RequiresPython},
+ {MDFieldName, meta.Info.Name},
+ {MDFieldVersion, meta.Info.Version},
+ {MDFieldSummary, meta.Info.Summary},
+ {MDFieldDescriptionContentType, meta.Info.DescriptionContentType},
+ {MDFieldKeywords, meta.Info.Keywords},
+ {MDFieldHomePage, meta.Info.HomePage},
+ {MDFieldAuthor, meta.Info.Author},
+ {MDFieldAuthorEmail, meta.Info.AuthorEmail},
+ {MDFieldMaintainer, meta.Info.Maintainer},
+ {MDFieldMaintainerEmail, meta.Info.MaintainerEmail},
+ {MDFieldLicense, meta.Info.License},
+ {MDFieldRequiresPython, meta.Info.RequiresPython},
} {
recField, jsonField := m[0], m[1]
if jsonField == "" {
continue
}
if _, err = wr.WriteFields(recfile.Field{
- Name: metadataFieldToRecField(recField),
+ Name: MDFieldToRecField[recField],
Value: jsonField,
}); err != nil {
log.Fatalln(err)
}
}
for _, m := range []RecFieldToValuesMap{
- {MetadataFieldClassifier, meta.Info.Classifier},
- {MetadataFieldPlatform, meta.Info.Platform},
- {MetadataFieldSupportedPlatform, meta.Info.SupportedPlatform},
- {MetadataFieldRequiresDist, meta.Info.RequiresDist},
- {MetadataFieldRequiresExternal, meta.Info.RequiresExternal},
- {MetadataFieldProjectURL, meta.Info.ProjectURL},
- {MetadataFieldProvidesExtra, meta.Info.ProvidesExtra},
+ {MDFieldClassifier, meta.Info.Classifier},
+ {MDFieldPlatform, meta.Info.Platform},
+ {MDFieldSupportedPlatform, meta.Info.SupportedPlatform},
+ {MDFieldRequiresDist, meta.Info.RequiresDist},
+ {MDFieldRequiresExternal, meta.Info.RequiresExternal},
+ {MDFieldProjectURL, meta.Info.ProjectURL},
+ {MDFieldProvidesExtra, meta.Info.ProvidesExtra},
} {
for _, v := range m.jsonFields {
if _, err = wr.WriteFields(recfile.Field{
- Name: metadataFieldToRecField(m.recField),
+ Name: MDFieldToRecField[m.recField],
Value: v,
}); err != nil {
log.Fatalln(err)
return false
}
for _, m := range [][2]string{
- {MetadataFieldName, metaStripped.Info.Name},
- {MetadataFieldVersion, metaStripped.Info.Version},
- {MetadataFieldSummary, metaStripped.Info.Summary},
- {MetadataFieldDescriptionContentType, metaStripped.Info.DescriptionContentType},
- {MetadataFieldKeywords, metaStripped.Info.Keywords},
- {MetadataFieldHomePage, metaStripped.Info.HomePage},
- {MetadataFieldAuthor, metaStripped.Info.Author},
- {MetadataFieldAuthorEmail, metaStripped.Info.AuthorEmail},
- {MetadataFieldMaintainer, metaStripped.Info.Maintainer},
- {MetadataFieldMaintainerEmail, metaStripped.Info.MaintainerEmail},
- {MetadataFieldLicense, metaStripped.Info.License},
- {MetadataFieldRequiresPython, metaStripped.Info.RequiresPython},
+ {MDFieldName, metaStripped.Info.Name},
+ {MDFieldVersion, metaStripped.Info.Version},
+ {MDFieldSummary, metaStripped.Info.Summary},
+ {MDFieldDescriptionContentType, metaStripped.Info.DescriptionContentType},
+ {MDFieldKeywords, metaStripped.Info.Keywords},
+ {MDFieldHomePage, metaStripped.Info.HomePage},
+ {MDFieldAuthor, metaStripped.Info.Author},
+ {MDFieldAuthorEmail, metaStripped.Info.AuthorEmail},
+ {MDFieldMaintainer, metaStripped.Info.Maintainer},
+ {MDFieldMaintainerEmail, metaStripped.Info.MaintainerEmail},
+ {MDFieldLicense, metaStripped.Info.License},
+ {MDFieldRequiresPython, metaStripped.Info.RequiresPython},
} {
recField, jsonField := m[0], m[1]
if jsonField == "" {
continue
}
if _, err = wr.WriteFields(recfile.Field{
- Name: metadataFieldToRecField(recField),
+ Name: MDFieldToRecField[recField],
Value: jsonField,
}); err != nil {
log.Fatalln(err)
}
for _, m := range []RecFieldToValuesMap{
- {MetadataFieldClassifier, metaStripped.Info.Classifier},
- {MetadataFieldRequiresDist, metaStripped.Info.RequiresDist},
+ {MDFieldClassifier, metaStripped.Info.Classifier},
+ {MDFieldRequiresDist, metaStripped.Info.RequiresDist},
} {
for _, v := range m.jsonFields {
if _, err = wr.WriteFields(recfile.Field{
- Name: metadataFieldToRecField(m.recField),
+ Name: MDFieldToRecField[m.recField],
Value: v,
}); err != nil {
log.Fatalln(err)
lines := strings.Split(description, "\n")
if len(lines) > 0 {
if _, err = wr.WriteFieldMultiline(
- MetadataFieldDescription, lines,
+ MDFieldDescription, lines,
); err != nil {
log.Fatalln(err)
}
if !mkdirForPkg(w, r, pkgName) {
return false
}
- path := filepath.Join(dirPath, MetadataFile)
+ path := filepath.Join(dirPath, MDFile)
existing, err := ioutil.ReadFile(path)
if err != nil || bytes.Compare(existing, buf.Bytes()) != 0 {
if err = WriteFileSync(dirPath, path, buf.Bytes(), now); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return false
}
- log.Println(r.RemoteAddr, "pypi", pkgName+"/"+MetadataFile, "touch")
+ log.Println(r.RemoteAddr, "pypi", pkgName+"/"+MDFile, "touch")
}
}
mtimes := make(map[string]time.Time)
var buf bytes.Buffer
wr := recfile.NewWriter(&buf)
- for _, m := range [][2]string{
- {"name", MetadataFieldName},
- {"version", MetadataFieldVersion},
- {"platform", MetadataFieldPlatform},
- {"supported_platform", MetadataFieldSupportedPlatform},
- {"summary", MetadataFieldSummary},
- {"description", MetadataFieldDescription},
- {"description_content_type", MetadataFieldDescriptionContentType},
- {"keywords", MetadataFieldKeywords},
- {"home_page", MetadataFieldHomePage},
- {"author", MetadataFieldAuthor},
- {"author_email", MetadataFieldAuthorEmail},
- {"maintainer", MetadataFieldMaintainer},
- {"maintainer_email", MetadataFieldMaintainerEmail},
- {"license", MetadataFieldLicense},
- {"classifiers", MetadataFieldClassifier},
- {"requires_dist", MetadataFieldRequiresDist},
- {"requires_python", MetadataFieldRequiresPython},
- {"requires_external", MetadataFieldRequiresExternal},
- {"project_url", MetadataFieldProjectURL},
- {"provides_extra", MetadataFieldProvidesExtra},
- } {
+ for _, m := range MDFormToRecField {
formField, recField := m[0], m[1]
if vs, exists := r.MultipartForm.Value[formField]; exists {
for _, v := range vs {
lines := strings.Split(v, "\n")
if len(lines) > 1 {
- _, err = wr.WriteFieldMultiline(
- metadataFieldToRecField(recField),
- lines,
- )
+ _, err = wr.WriteFieldMultiline(recField, lines)
} else {
_, err = wr.WriteFields(recfile.Field{
- Name: metadataFieldToRecField(recField),
+ Name: recField,
Value: lines[0],
})
}
}
}
}
- path := filepath.Join(dirPath, MetadataFile)
+ path := filepath.Join(dirPath, MDFile)
if err = WriteFileSync(dirPath, path, buf.Bytes(), now); err != nil {
log.Println("error", r.RemoteAddr, path, err)
http.Error(w, err.Error(), http.StatusInternalServerError)