mediocregopher/mediocre-blog
1
0
Fork 0
Code Pull Requests Releases Activity

delete some old script that aren't needed anymore

Browse Source
This commit is contained in:
Brian Picciano 2022-08-18 20:28:04 -06:00
parent 60018dd9f5
commit 062e5bbd10
3 changed files with 0 additions and 300 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

114
srv/src/cmd/import-asset/main.go
View File

@ -1,114 +0,0 @@
package main
import (
"bufio"
"context"
"errors"
"fmt"
"io"
"os"
"strings"
cfgpkg "github.com/mediocregopher/blog.mediocregopher.com/srv/cfg"
"github.com/mediocregopher/blog.mediocregopher.com/srv/post"
"github.com/mediocregopher/mediocre-go-lib/v2/mctx"
"github.com/mediocregopher/mediocre-go-lib/v2/mlog"
)
func importAsset(assetStore post.AssetStore, id, path string) error {
f, err := os.Open(path)
if err != nil {
return fmt.Errorf("opening file: %w", err)
}
defer f.Close()
if err := assetStore.Set(id, f); err != nil {
return fmt.Errorf("setting into asset store: %w", err)
}
return nil
}
func main() {
ctx := context.Background()
cfg := cfgpkg.NewBlogCfg(cfgpkg.Params{})
var dataDir cfgpkg.DataDir
dataDir.SetupCfg(cfg)
defer dataDir.Close()
ctx = mctx.WithAnnotator(ctx, &dataDir)
id := cfg.String("id", "", "ID the asset will be stored under")
path := cfg.String("path", "", "Path the asset should be imported from")
fromStdin := cfg.Bool("from-stdin", false, "If set, ignore id and path, read space separated id/path pairs from stdin")
// initialization
err := cfg.Init(ctx)
logger := mlog.NewLogger(nil)
defer logger.Close()
if !*fromStdin && (*id == "" || *path == "") {
logger.FatalString(ctx, "-id and -path are required if -from-stdin is not given")
}
logger.Info(ctx, "process started")
defer logger.Info(ctx, "process exiting")
if err != nil {
logger.Fatal(ctx, "initializing", err)
}
postDB, err := post.NewSQLDB(dataDir)
if err != nil {
logger.Fatal(ctx, "initializing post sql db", err)
}
defer postDB.Close()
assetStore := post.NewAssetStore(postDB)
if !*fromStdin {
ctx := mctx.Annotate(ctx, "id", *id, "path", *path)
if err := importAsset(assetStore, *id, *path); err != nil {
logger.Fatal(ctx, "failed to import asset", err)
}
logger.Info(ctx, "asset stored")
return
}
for stdin := bufio.NewReader(os.Stdin); ; {
line, err := stdin.ReadString('\n')
if errors.Is(err, io.EOF) {
return
} else if err != nil {
logger.Fatal(ctx, "reading from stdin", err)
}
fields := strings.Fields(line)
if len(fields) < 2 {
ctx := mctx.Annotate(ctx, "line", line)
logger.FatalString(ctx, "cannot process line with fewer than 2 fields")
}
id, path := fields[0], fields[1]
ctx := mctx.Annotate(ctx, "id", id, "path", path)
if err := importAsset(assetStore, id, path); err != nil {
logger.Fatal(ctx, "failed to import asset", err)
}
logger.Info(ctx, "asset stored")
}
}

18
srv/src/cmd/import-asset/to-import.txt
View File

@ -1,18 +0,0 @@
diamond-square-terrain.png ../../static/src/img/diamond-square/terrain.png
diamond-square-dsalg.png ../../static/src/img/diamond-square/dsalg.png
program-structure-diag1.jpg ../../static/src/img/program-structure/diag1.jpg
program-structure-diag2.jpg ../../static/src/img/program-structure/diag2.jpg
program-structure-diag3.jpg ../../static/src/img/program-structure/diag3.jpg
open-infra-keybase.png ../../static/src/img/open-infra/keybase.png
wedding-1.jpg ../../static/src/img/wedding/1.jpg
wedding-2.jpg ../../static/src/img/wedding/2.jpg
wedding-3.jpg ../../static/src/img/wedding/3.jpg
happy-tree-partial.png ../../static/src/img/happy-tree/partial.png
happy-tree-atmp1.png ../../static/src/img/happy-tree/happy-tree-atmp1.png
happy-tree-atmp2.png ../../static/src/img/happy-tree/happy-tree-atmp2.png
happy-tree-atmp3-pow3.png ../../static/src/img/happy-tree/happy-tree-atmp3-pow3.png
happy-tree-atmp3-pow4.png ../../static/src/img/happy-tree/happy-tree-atmp3-pow4.png
happy-tree-atmp3-pow5.png ../../static/src/img/happy-tree/happy-tree-atmp3-pow5.png
happy-tree-atmp3-pow6.png ../../static/src/img/happy-tree/happy-tree-atmp3-pow6.png
nfts-disaster-girl.jpg ../../static/src/img/nfts/disaster-girl.jpg
nfts-gleaners.jpg ../../static/src/img/nfts/gleaners.jpg

168
srv/src/cmd/import-posts/main.go
View File

@ -1,168 +0,0 @@
package main
import (
"context"
"fmt"
"os"
"path/filepath"
"regexp"
"strings"
"time"
"github.com/adrg/frontmatter"
cfgpkg "github.com/mediocregopher/blog.mediocregopher.com/srv/cfg"
"github.com/mediocregopher/blog.mediocregopher.com/srv/post"
"github.com/mediocregopher/mediocre-go-lib/v2/mctx"
"github.com/mediocregopher/mediocre-go-lib/v2/mlog"
)
type postFrontmatter struct {
Title string `yaml:"title"`
Description string `yaml:"description"`
Tags string `yaml:"tags"`
Series string `yaml:"series"`
Updated string `yaml:"updated"`
}
func parseDate(str string) (time.Time, error) {
const layout = "2006-01-02"
return time.Parse(layout, str)
}
var postNameRegexp = regexp.MustCompile(`(20..-..-..)-([^.]+).md`)
func importPost(postStore post.Store, path string) (post.StoredPost, error) {
fileName := filepath.Base(path)
fileNameMatches := postNameRegexp.FindStringSubmatch(fileName)
if len(fileNameMatches) != 3 {
return post.StoredPost{}, fmt.Errorf("file name %q didn't match regex", fileName)
}
publishedAtStr := fileNameMatches[1]
publishedAt, err := parseDate(publishedAtStr)
if err != nil {
return post.StoredPost{}, fmt.Errorf("parsing publish date %q: %w", publishedAtStr, err)
}
postID := fileNameMatches[2]
f, err := os.Open(path)
if err != nil {
return post.StoredPost{}, fmt.Errorf("opening file: %w", err)
}
defer f.Close()
var matter postFrontmatter
body, err := frontmatter.Parse(f, &matter)
if err != nil {
return post.StoredPost{}, fmt.Errorf("parsing frontmatter: %w", err)
}
// if there is already a post for this ID, delete it, we're overwriting
if err := postStore.Delete(postID); err != nil {
return post.StoredPost{}, fmt.Errorf("deleting post id %q: %w", postID, err)
}
p := post.Post{
ID: postID,
Title: matter.Title,
Description: matter.Description,
Tags: strings.Fields(matter.Tags),
Series: matter.Series,
Body: string(body),
}
if _, err := postStore.Set(p, publishedAt); err != nil {
return post.StoredPost{}, fmt.Errorf("storing post id %q: %w", p.ID, err)
}
if matter.Updated != "" {
lastUpdatedAt, err := parseDate(matter.Updated)
if err != nil {
return post.StoredPost{}, fmt.Errorf("parsing updated date %q: %w", matter.Updated, err)
}
// as a hack, we store the post again with the updated date as now. This
// will update the LastUpdatedAt field in the Store.
if _, err := postStore.Set(p, lastUpdatedAt); err != nil {
return post.StoredPost{}, fmt.Errorf("updating post id %q: %w", p.ID, err)
}
}
storedPost, err := postStore.GetByID(p.ID)
if err != nil {
return post.StoredPost{}, fmt.Errorf("retrieving stored post by id %q: %w", p.ID, err)
}
return storedPost, nil
}
func main() {
ctx := context.Background()
cfg := cfgpkg.NewBlogCfg(cfgpkg.Params{})
var dataDir cfgpkg.DataDir
dataDir.SetupCfg(cfg)
defer dataDir.Close()
ctx = mctx.WithAnnotator(ctx, &dataDir)
paths := cfg.Args("<post file paths...>")
// initialization
err := cfg.Init(ctx)
logger := mlog.NewLogger(nil)
defer logger.Close()
logger.Info(ctx, "process started")
defer logger.Info(ctx, "process exiting")
if err != nil {
logger.Fatal(ctx, "initializing", err)
}
if len(*paths) == 0 {
logger.FatalString(ctx, "no paths given")
}
postDB, err := post.NewSQLDB(dataDir)
if err != nil {
logger.Fatal(ctx, "initializing post sql db", err)
}
defer postDB.Close()
postStore := post.NewStore(postDB)
for _, path := range *paths {
ctx := mctx.Annotate(ctx, "postPath", path)
storedPost, err := importPost(postStore, path)
if err != nil {
logger.Error(ctx, "importing post", err)
}
ctx = mctx.Annotate(ctx,
"postID", storedPost.ID,
"postTitle", storedPost.Title,
"postDescription", storedPost.Description,
"postTags", storedPost.Tags,
"postSeries", storedPost.Series,
"postPublishedAt", storedPost.PublishedAt,
)
if !storedPost.LastUpdatedAt.IsZero() {
ctx = mctx.Annotate(ctx,
"postLastUpdatedAt", storedPost.LastUpdatedAt)
}
logger.Info(ctx, "post stored")
}
}