From 4f01edb9230f58ff84b0dd892c931ec8ac9aad55 Mon Sep 17 00:00:00 2001 From: Brian Picciano Date: Tue, 13 Sep 2022 12:56:08 +0200 Subject: move src out of srv, clean up default.nix and Makefile --- src/cmd/hash-password/main.go | 23 +++++++ src/cmd/load-test-data/galaxy.jpg | Bin 0 -> 69901 bytes src/cmd/load-test-data/main.go | 129 +++++++++++++++++++++++++++++++++++ src/cmd/load-test-data/test-data.yml | 85 +++++++++++++++++++++++ src/cmd/mailinglist-cli/main.go | 118 ++++++++++++++++++++++++++++++++ src/cmd/mediocre-blog/main.go | 128 ++++++++++++++++++++++++++++++++++ 6 files changed, 483 insertions(+) create mode 100644 src/cmd/hash-password/main.go create mode 100644 src/cmd/load-test-data/galaxy.jpg create mode 100644 src/cmd/load-test-data/main.go create mode 100644 src/cmd/load-test-data/test-data.yml create mode 100644 src/cmd/mailinglist-cli/main.go create mode 100644 src/cmd/mediocre-blog/main.go (limited to 'src/cmd') diff --git a/src/cmd/hash-password/main.go b/src/cmd/hash-password/main.go new file mode 100644 index 0000000..47ae1e7 --- /dev/null +++ b/src/cmd/hash-password/main.go @@ -0,0 +1,23 @@ +package main + +import ( + "bufio" + "fmt" + "os" + "strings" + + "github.com/mediocregopher/blog.mediocregopher.com/srv/http" +) + +func main() { + + fmt.Fprint(os.Stderr, "Password: ") + + line, err := bufio.NewReader(os.Stdin).ReadString('\n') + + if err != nil { + panic(err) + } + + fmt.Println(http.NewPasswordHash(strings.TrimSpace(line))) +} diff --git a/src/cmd/load-test-data/galaxy.jpg b/src/cmd/load-test-data/galaxy.jpg new file mode 100644 index 0000000..a2ee2d1 Binary files /dev/null and b/src/cmd/load-test-data/galaxy.jpg differ diff --git a/src/cmd/load-test-data/main.go b/src/cmd/load-test-data/main.go new file mode 100644 index 0000000..5ebee32 --- /dev/null +++ b/src/cmd/load-test-data/main.go @@ -0,0 +1,129 @@ +package main + +import ( + "context" + "fmt" + "os" + "path/filepath" + "time" + + 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" + "gopkg.in/yaml.v3" +) + +type testData struct { + PublishedPosts []post.Post `yaml:"published_posts"` + Assets map[string]string +} + +func loadTestData(path string) (testData, error) { + + f, err := os.Open(path) + if err != nil { + return testData{}, fmt.Errorf("opening file: %w", err) + } + defer f.Close() + + var res testData + + if err := yaml.NewDecoder(f).Decode(&res); err != nil { + return testData{}, fmt.Errorf("decoding file contents: %w", err) + } + + return res, 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) + + testDataPath := cfg.String("test-data-path", "./test-data.yml", "File containing the data to be loaded in") + + // 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) + } + + testDataDir := filepath.Dir(*testDataPath) + + testData, err := loadTestData(*testDataPath) + if err != nil { + logger.Fatal(ctx, "loading test data", err) + } + + postDB, err := post.NewSQLDB(dataDir) + if err != nil { + logger.Fatal(ctx, "initializing post sql db", err) + } + defer postDB.Close() + + { + + postStore := post.NewStore(postDB) + + now := time.Now().Truncate(time.Hour) + + for _, post := range testData.PublishedPosts { + + ctx := mctx.Annotate(ctx, + "postID", post.ID, + "now", now) + + if _, err := postStore.Set(post, now); err != nil { + logger.Fatal(ctx, "setting post", err) + } + + logger.Info(ctx, "set post") + + now = now.Add(-1 * time.Hour) + } + + } + + { + assetStore := post.NewAssetStore(postDB) + + setAsset := func(assetID, assetPath string) error { + assetFullPath := filepath.Join(testDataDir, assetPath) + + f, err := os.Open(assetFullPath) + if err != nil { + return fmt.Errorf("opening %q for reading: %w", assetFullPath, err) + } + defer f.Close() + + return assetStore.Set(assetID, f) + } + + for assetID, assetPath := range testData.Assets { + + ctx := mctx.Annotate(ctx, + "assetID", assetID, + "assetPath", assetPath) + + if err := setAsset(assetID, assetPath); err != nil { + logger.Fatal(ctx, "setting asset", err) + } + + logger.Info(ctx, "set asset") + } + } +} diff --git a/src/cmd/load-test-data/test-data.yml b/src/cmd/load-test-data/test-data.yml new file mode 100644 index 0000000..51a08c5 --- /dev/null +++ b/src/cmd/load-test-data/test-data.yml @@ -0,0 +1,85 @@ +--- + +published_posts: + + - id: markdown-test + title: Markdown Test + description: A little post containing different kinds of markdown elements. + tags: + - foo + series: testing + body: | + + This here's a test post containing various markdown elements in its body. + It's useful for making sure that posts will look good (generally). + + ## Let's Begin + + There's various things worth testing. _Emphasized_ and **bold** text are + great starting points. Also `little bits of code`. + + One might consider making a list of them. + + * A bit normal. + * _A bit emphasized_ + * **A bit bold** + * `A bit of code.` + + So many! + + ### A Subsection + + Crazy. Another way to delineate a subsection is with a horizontal rule. + + ----- + + And it only gets crazier from here! + + Check out this code block. + + ``` + // It's like actually being in the matrix + for !dead { + if awake { + work() + } else { + continue + } + } + ``` + + Edgy. + + #### Side-note + + Did you know that the terms "cyberspace" and "matrix" are attributable to a book from 1984 called _Neuromancer_? + + > The 1999 cyberpunk science fiction film The Matrix particularly draws from Neuromancer both eponym and usage of the term "matrix". + > - Wikipedia + + Here's a real picture of cyberspace. + + ![not a sound stage]({{ AssetURL "galaxy.jpg" }}) + + This has been a great post. + + - id: empty-test + title: Empty Test + description: A post with no content. Might as well test it. + tags: + - foo + - bar + series: testing + body: "" + + - id: little-markdown-test + title: Little Markdown Test + description: A post with almost no content. + tags: + - bar + series: testing + body: | + This page is almost empty. + +assets: + galaxy.jpg: ./galaxy.jpg diff --git a/src/cmd/mailinglist-cli/main.go b/src/cmd/mailinglist-cli/main.go new file mode 100644 index 0000000..c090f41 --- /dev/null +++ b/src/cmd/mailinglist-cli/main.go @@ -0,0 +1,118 @@ +package main + +import ( + "context" + "errors" + "io" + + "github.com/mediocregopher/blog.mediocregopher.com/srv/cfg" + cfgpkg "github.com/mediocregopher/blog.mediocregopher.com/srv/cfg" + "github.com/mediocregopher/blog.mediocregopher.com/srv/mailinglist" + "github.com/mediocregopher/mediocre-go-lib/v2/mctx" + "github.com/mediocregopher/mediocre-go-lib/v2/mlog" + "github.com/tilinna/clock" +) + +func main() { + + ctx := context.Background() + + cfg := cfgpkg.NewBlogCfg(cfg.Params{}) + + var dataDir cfgpkg.DataDir + dataDir.SetupCfg(cfg) + defer dataDir.Close() + ctx = mctx.WithAnnotator(ctx, &dataDir) + + var mailerParams mailinglist.MailerParams + mailerParams.SetupCfg(cfg) + ctx = mctx.WithAnnotator(ctx, &mailerParams) + + var mlParams mailinglist.Params + mlParams.SetupCfg(cfg) + ctx = mctx.WithAnnotator(ctx, &mlParams) + + // 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) + } + + clock := clock.Realtime() + + var mailer mailinglist.Mailer + if mailerParams.SMTPAddr == "" { + logger.Info(ctx, "-smtp-addr not given, using NullMailer") + mailer = mailinglist.NullMailer + } else { + mailer = mailinglist.NewMailer(mailerParams) + } + + mlStore, err := mailinglist.NewStore(dataDir) + if err != nil { + logger.Fatal(ctx, "initializing mailing list storage", err) + } + defer mlStore.Close() + + mlParams.Store = mlStore + mlParams.Mailer = mailer + mlParams.Clock = clock + + ml := mailinglist.New(mlParams) + + subCmd := cfg.SubCmd() + ctx = mctx.Annotate(ctx, "subCmd", subCmd) + + switch subCmd { + + case "list": + + for it := mlStore.GetAll(); ; { + email, err := it() + if errors.Is(err, io.EOF) { + break + } else if err != nil { + logger.Fatal(ctx, "retrieving next email", err) + } + + ctx := mctx.Annotate(context.Background(), + "email", email.Email, + "createdAt", email.CreatedAt, + "verifiedAt", email.VerifiedAt, + ) + + logger.Info(ctx, "next") + } + + case "publish": + + title := cfg.String("title", "", "Title of the post which was published") + url := cfg.String("url", "", "URL of the post which was published") + + if err := cfg.Init(ctx); err != nil { + logger.Fatal(ctx, "initializing", err) + } + + if *title == "" { + logger.FatalString(ctx, "-title is required") + + } else if *url == "" { + logger.FatalString(ctx, "-url is required") + } + + err := ml.Publish(*title, *url) + if err != nil { + logger.Fatal(ctx, "publishing", err) + } + + default: + logger.FatalString(ctx, "invalid sub-command, must be list|publish") + } +} diff --git a/src/cmd/mediocre-blog/main.go b/src/cmd/mediocre-blog/main.go new file mode 100644 index 0000000..6b41e04 --- /dev/null +++ b/src/cmd/mediocre-blog/main.go @@ -0,0 +1,128 @@ +package main + +import ( + "context" + "os" + "os/signal" + "syscall" + "time" + + cfgpkg "github.com/mediocregopher/blog.mediocregopher.com/srv/cfg" + "github.com/mediocregopher/blog.mediocregopher.com/srv/http" + "github.com/mediocregopher/blog.mediocregopher.com/srv/mailinglist" + "github.com/mediocregopher/blog.mediocregopher.com/srv/post" + "github.com/mediocregopher/blog.mediocregopher.com/srv/pow" + "github.com/mediocregopher/mediocre-go-lib/v2/mctx" + "github.com/mediocregopher/mediocre-go-lib/v2/mlog" + "github.com/tilinna/clock" +) + +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) + + var powMgrParams pow.ManagerParams + powMgrParams.SetupCfg(cfg) + ctx = mctx.WithAnnotator(ctx, &powMgrParams) + + var mailerParams mailinglist.MailerParams + mailerParams.SetupCfg(cfg) + ctx = mctx.WithAnnotator(ctx, &mailerParams) + + var mlParams mailinglist.Params + mlParams.SetupCfg(cfg) + ctx = mctx.WithAnnotator(ctx, &mlParams) + + var httpParams http.Params + httpParams.SetupCfg(cfg) + ctx = mctx.WithAnnotator(ctx, &httpParams) + + // 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) + } + + clock := clock.Realtime() + + powStore := pow.NewMemoryStore(clock) + defer powStore.Close() + + powMgrParams.Store = powStore + powMgrParams.Clock = clock + + powMgr := pow.NewManager(powMgrParams) + + var mailer mailinglist.Mailer + if mailerParams.SMTPAddr == "" { + logger.Info(ctx, "-smtp-addr not given, using a fake Mailer") + mailer = mailinglist.NewLogMailer(logger.WithNamespace("fake-mailer")) + } else { + mailer = mailinglist.NewMailer(mailerParams) + } + + mlStore, err := mailinglist.NewStore(dataDir) + if err != nil { + logger.Fatal(ctx, "initializing mailing list storage", err) + } + defer mlStore.Close() + + mlParams.Store = mlStore + mlParams.Mailer = mailer + mlParams.Clock = clock + + ml := mailinglist.New(mlParams) + + postSQLDB, err := post.NewSQLDB(dataDir) + if err != nil { + logger.Fatal(ctx, "initializing sql db for post data", err) + } + defer postSQLDB.Close() + + postStore := post.NewStore(postSQLDB) + postAssetStore := post.NewAssetStore(postSQLDB) + postDraftStore := post.NewDraftStore(postSQLDB) + + httpParams.Logger = logger.WithNamespace("http") + httpParams.PowManager = powMgr + httpParams.PostStore = postStore + httpParams.PostAssetStore = postAssetStore + httpParams.PostDraftStore = postDraftStore + httpParams.MailingList = ml + + logger.Info(ctx, "listening") + httpAPI, err := http.New(httpParams) + if err != nil { + logger.Fatal(ctx, "initializing http api", err) + } + defer func() { + shutdownCtx, cancel := context.WithTimeout(ctx, 5*time.Second) + defer cancel() + + if err := httpAPI.Shutdown(shutdownCtx); err != nil { + logger.Fatal(ctx, "shutting down http api", err) + } + }() + + // wait + + sigCh := make(chan os.Signal, 1) + signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM) + <-sigCh + + // let the defers begin +} -- cgit v1.2.3