end-to-end dryRun

cmd/app/cmd.go

@@ -3,6 +3,8 @@ package app
 import (
 	"context"
 	"flag"
+	"io"
+	"os"
 
 	"github.com/gardener/docforge/pkg/hugo"
 	"github.com/spf13/cobra"
@@ -92,9 +94,10 @@ func (flags *cmdFlags) Configure(command *cobra.Command) {
 // NewOptions creates an options object from flags
 func NewOptions(f *cmdFlags) *Options {
 	var (
-		tokens      map[string]string
-		metering    *Metering
-		hugoOptions *hugo.Options
+		tokens       map[string]string
+		metering     *Metering
+		hugoOptions  *hugo.Options
+		dryRunWriter io.Writer
 	)
 	if len(f.ghOAuthToken) > 0 {
 		tokens = map[string]string{
@@ -115,6 +118,10 @@ func NewOptions(f *cmdFlags) *Options {
 		}
 	}
 
+	if f.dryRun {
+		dryRunWriter = os.Stdout
+	}
+
 	return &Options{
 		DestinationPath:              f.destinationPath,
 		FailFast:                     f.failFast,
@@ -125,6 +132,7 @@ func NewOptions(f *cmdFlags) *Options {
 		MarkdownFmt:                  f.markdownFmt,
 		GitHubTokens:                 tokens,
 		Metering:                     metering,
+		DryRunWriter:                 dryRunWriter,
 		Hugo:                         hugoOptions,
 	}
 }

cmd/app/factory.go

@@ -2,6 +2,7 @@ package app
 
 import (
 	"context"
+	"io"
 	"path/filepath"
 
 	"github.com/gardener/docforge/pkg/hugo"
@@ -30,6 +31,7 @@ type Options struct {
 	MarkdownFmt                  bool
 	GitHubTokens                 map[string]string
 	Metering                     *Metering
+	DryRunWriter                 io.Writer
 	Hugo                         *hugo.Options
 }
 
@@ -50,13 +52,23 @@ func NewReactor(ctx context.Context, options *Options) *reactor.Reactor {
 		ResourceDownloadWorkersCount: options.ResourceDownloadWorkersCount,
 		MarkdownFmt:                  options.MarkdownFmt,
 		Processor:                    nil,
-		Writer: &writers.FSWriter{
+		ResourceHandlers:             initResourceHanlders(ctx, options),
+		DryRunWriter:                 options.DryRunWriter,
+	}
+	if options.DryRunWriter != nil {
+		o.Writer = &writers.DryRunWriter{
+			Writer: options.DryRunWriter,
+		}
+		o.ResourceDownloadWriter = &writers.DryRunWriter{
+			Writer: options.DryRunWriter,
+		}
+	} else {
+		o.Writer = &writers.FSWriter{
 			Root: options.DestinationPath,
-		},
-		ResourceDownloadWriter: &writers.FSWriter{
+		}
+		o.ResourceDownloadWriter = &writers.FSWriter{
 			Root: filepath.Join(options.DestinationPath, options.ResourcesPath),
-		},
-		ResourceHandlers: initResourceHanlders(ctx, options),
+		}
 	}
 
 	if options.Hugo != nil {
@@ -76,8 +88,14 @@ func WithHugo(reactorOptions *reactor.Options, o *Options) {
 			hugo.NewProcessor(hugoOptions),
 		},
 	}
-	hugoOptions.Writer = &writers.FSWriter{
-		Root: filepath.Join(o.DestinationPath),
+	if o.DryRunWriter != nil {
+		hugoOptions.Writer = &writers.DryRunWriter{
+			Writer: o.DryRunWriter,
+		}
+	} else {
+		hugoOptions.Writer = &writers.FSWriter{
+			Root: filepath.Join(o.DestinationPath),
+		}
 	}
 	reactorOptions.Writer = hugo.NewWriter(hugoOptions)
 }

pkg/jobs/controller_test.go

@@ -82,13 +82,13 @@ func TestController(t *testing.T) {
 			ctx, cancel := context.WithTimeout(context.Background(), tc.timeout)
 			defer cancel()
 			job := &Job{
-				FailFast:          tc.failFast,
-				ID:                "Test",
-				MaxWorkers:        tc.workersCount,
-				MinWorkers:        tc.workersCount,
+				FailFast:                  tc.failFast,
+				ID:                        "Test",
+				MaxWorkers:                tc.workersCount,
+				MinWorkers:                tc.workersCount,
 				IsWorkerExitsOnEmptyQueue: true,
-				Worker:            WorkerFunc(tc.worker.work),
-				Queue:             NewWorkQueue(tc.tasksCount),
+				Worker:                    WorkerFunc(tc.worker.work),
+				Queue:                     NewWorkQueue(tc.tasksCount),
 			}
 
 			c := NewController(job)

pkg/reactor/content_processor.go

@@ -157,6 +157,7 @@ func (c *NodeContentProcessor) reconcileHTMLLinks(ctx context.Context, docNode *
 	return documentBytes, errors.ErrorOrNil()
 }
 
+// Download represents a resource that can be downloaded
 type Download struct {
 	url          string
 	resourceName string

pkg/reactor/reactor.go

@@ -3,6 +3,7 @@ package reactor
 import (
 	"context"
 	"fmt"
+	"io"
 
 	"github.com/gardener/docforge/pkg/processors"
 	"k8s.io/klog/v2"
@@ -26,6 +27,7 @@ type Options struct {
 	ResourceDownloadWriter writers.Writer
 	Writer                 writers.Writer
 	ResourceHandlers       []resourcehandlers.ResourceHandler
+	DryRunWriter           io.Writer
 }
 
 // NewReactor creates a Reactor from Options
@@ -44,6 +46,7 @@ func NewReactor(o *Options) *Reactor {
 		ResourceHandlers:   rhRegistry,
 		DocController:      docController,
 		DownloadController: downloadController,
+		DryRunWriter:       o.DryRunWriter,
 	}
 	return r
 }
@@ -55,6 +58,7 @@ type Reactor struct {
 	localityDomain     *localityDomain
 	DocController      DocumentController
 	DownloadController DownloadController
+	DryRunWriter       io.Writer
 }
 
 // Run starts build operation on docStruct
@@ -77,8 +81,8 @@ func (r *Reactor) Run(ctx context.Context, docStruct *api.Documentation, dryRun
 		if err != nil {
 			return err
 		}
-		fmt.Println(s)
-		return nil
+		r.DryRunWriter.Write([]byte(s))
+		r.DryRunWriter.Write([]byte("\n\n"))
 	}
 
 	ctx, cancel := context.WithCancel(ctx)

pkg/writers/dryRunWriter.go

@@ -0,0 +1,32 @@
+package writers
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/gardener/docforge/pkg/api"
+)
+
+// DryRunWriter is implementation of Writer interface for writing blobs to the file system
+type DryRunWriter struct {
+	Writer io.Writer
+	Root   string
+	root   *file
+}
+
+type file struct {
+	name   string
+	indent int
+}
+
+type folder struct {
+	file
+	files []*file
+}
+
+func (f *DryRunWriter) Write(name, path string, docBlob []byte, node *api.Node) error {
+	fmt.Printf("writing %s/%s\n", path, name)
+	// TODO: write file/folder structure synchronizing parallel write requests
+	// into a single hierarchy
+	return nil
+}