Merge pull request #2 from jpnt/alpha

Merge Alpha

Author: jpnt

.gitignore

@@ -1,4 +1,4 @@
 TODO.md
-kman
+kman*
 *old
 linux*

README.md

@@ -3,10 +3,61 @@
 kman aims to automate and unify the Linux Kernel installation from source process, allowing for a
 repeatable way of installing a Linux kernel, generating a initramfs image and updating
 the bootloader configuration, based on the tools and configurations available of your system,
-offering a sane and powerful way to manage kernels on any Linux distribution.
+offering a sane and powerful way to manage kernels in any Linux distribution.
 
-## Features
+## Installation process
+
+### Via precompiled binaries
+
+1. Go to [releases](https://github.com/jpnt/kman/releases)
+
+2. Download binary for your architecture
+
+3. Make the binary executable
+
+```sh
+chmod +x kman-amd64 
+```
+
+4. Verify installation
+
+```sh
+kman -version
+```
+
+### Via Go get (for go devs)
+
+```sh
+go install github.com/yourrepo/kman@latest
+kman --version
+```
 
+### Build from source
+
+```sh
+git clone https://github.com/yourrepo/kman.git && cd kman
+go mod tidy # install deps
+go build -o kman ./cmd/kman
+kman --version
+```
+
+## Examples
+
+- Run everything (download, compile, install, etc)
+
+```sh
+$ kman run-all
+```
+
+- Run a specific step(s)
+
+TODO: is it possible to simplify even further?
+
+```sh
+$ kman install,bootloader,initramfs --dir=./kernel-6.9.9 --initramfs=booster
+```
+
+## Features
 
 - [x] Minimal external libraries
 - [x] Cross‑distro compatibility

cmd/kman/kman.go

@@ -9,20 +9,16 @@ import (
 )
 
 func main() {
-	l := logger.NewLogger(logger.InfoLevel)
-
+	log := logger.NewLogger(logger.InfoLevel)
 	ctx := core.NewKernelContext()
-	p := core.NewPipeline(ctx)
-	f := service.NewStepFactory()
-
-	b := core.NewPipelineBuilder(l, p, f)
+	factory := service.NewStepFactory()
+	builder := core.NewPipelineBuilder(log, factory, ctx)
 
-	b = b.WithDefault()
-	// TODO: dynamic argument builder configuration
+	pipeline := builder.WithDefault().Build()
 
-	err := p.Run()
+	err := pipeline.Run()
 	if err != nil {
-		l.Error("Error: %s", err.Error())
+		log.Error("%s", err.Error())
 		os.Exit(1)
 	}
 }

internal/core/pipeline.go

@@ -2,52 +2,50 @@ package core
 
 import (
 	"fmt"
+	"time"
+
+	"github.com/jpnt/kman/pkg/logger"
 )
 
 type IPipeline interface {
-	AddStep(step IStep)
-	Steps() []IStep
-	Ctx() IKernelContext
 	Run() error
 }
 
 type Pipeline struct {
+	log   logger.ILogger
 	steps []IStep
 	ctx   IKernelContext
 }
 
 // Ensure struct implements interface
 var _ IPipeline = (*Pipeline)(nil)
 
-func NewPipeline(c IKernelContext) *Pipeline {
-	return &Pipeline{ctx: c}
-}
-
-func (pl *Pipeline) AddStep(step IStep) {
-	pl.steps = append(pl.steps, step)
-}
-
-func (pl *Pipeline) Steps() []IStep {
-	return pl.steps
-}
-
-func (pl *Pipeline) Ctx() IKernelContext {
-	return pl.ctx
-}
-
 func (pl *Pipeline) Run() error {
-	if len(pl.Steps()) == 0 {
+	if len(pl.steps) == 0 {
 		return fmt.Errorf("no steps were configured")
 	}
 
+	pl.log.Info("The following steps will be executed:")
 	for _, step := range pl.steps {
+		pl.log.Info("- %s", step.Name())
+	}
+
+	pl.log.Info("Starting execution ...")
+
+	for _, step := range pl.steps {
+		start := time.Now()
+		pl.log.Info("==> Starting step: %s ...", step.Name())
+
 		if err := pl.ctx.Validate(step.Name()); err != nil {
 			return fmt.Errorf("validation failed for step %q: %w", step.Name(), err)
 		}
 
 		if err := step.Execute(); err != nil {
 			return fmt.Errorf("execution failed for step %q: %w", step.Name(), err)
 		}
+
+		duration := time.Since(start)
+		pl.log.Info("<== Completed step: %s in %s", step.Name(), duration)
 	}
 	return nil
 }

internal/core/pipeline_builder.go

@@ -1,47 +1,52 @@
 package core
 
+// https://refactoring.guru/design-patterns/builder
+
 import (
 	"github.com/jpnt/kman/pkg/logger"
 )
 
 type IPipelineBuilder interface {
 	WithStep(stepName string) IPipelineBuilder
 	WithDefault() IPipelineBuilder
+	Build() IPipeline
 }
 
 type PipelineBuilder struct {
 	logger  logger.ILogger
-	pl      IPipeline
 	factory IStepFactory
+	ctx     IKernelContext
+	steps   []IStep
 }
 
 // Ensure struct implements interface
 var _ IPipelineBuilder = (*PipelineBuilder)(nil)
 
-func NewPipelineBuilder(l logger.ILogger, p IPipeline, f IStepFactory) IPipelineBuilder {
-	return &PipelineBuilder{logger: l, pl: p, factory: f}
+func NewPipelineBuilder(l logger.ILogger, f IStepFactory, c IKernelContext) IPipelineBuilder {
+	return &PipelineBuilder{logger: l, factory: f, ctx: c}
 }
 
 func (b *PipelineBuilder) WithStep(stepName string) IPipelineBuilder {
-	step, err := b.factory.CreateStep(stepName, b.logger, b.pl.Ctx())
+	step, err := b.factory.CreateStep(stepName, b.logger, b.ctx)
 	if err != nil {
-		b.logger.Warn("Unrecognized step: %q", stepName)
+		b.logger.Warn("Failed to create step %s: %s", stepName, err)
 		return b
 	}
-	b.pl.AddStep(step)
+	b.steps = append(b.steps, step)
+
 	return b
 }
 
 func (b *PipelineBuilder) WithDefault() IPipelineBuilder {
-	return b.
-		WithStep("list").
-		WithStep("download").
-		WithStep("verify").
-		WithStep("extract").
-		WithStep("patch").
-		WithStep("configure").
-		WithStep("compile").
-		WithStep("install").
-		WithStep("initramfs").
-		WithStep("bootloader")
+	availableSteps := b.factory.AvailableSteps()
+
+	for _, stepName := range availableSteps {
+		b.WithStep(stepName)
+	}
+
+	return b
+}
+
+func (b *PipelineBuilder) Build() IPipeline {
+	return &Pipeline{log: b.logger, ctx: b.ctx, steps: b.steps}
 }

internal/core/step.go

@@ -2,7 +2,11 @@ package core
 
 type IStep interface {
 	Name() string
-	// CtxParamsNeeded() []string // TODO: simpler way?
+	// NeedParams() []string // TODO: simpler way?
+	// This serves for the use case of when I only want
+	// to run a set of steps. And for those steps if I have
+	// not defined the required kernel context parameters
+	// then it should warn the users. Speficy in the command
+	// line arguments or prompt the user? What is more suckless
 	Execute() error
-	// Completed() bool
 }

internal/core/step_factory.go

@@ -5,5 +5,6 @@ import (
 )
 
 type IStepFactory interface {
-	CreateStep(name string, logger logger.ILogger, ctx IKernelContext) (IStep, error)
+	AvailableSteps() []string
+	CreateStep(name string, log logger.ILogger, ctx IKernelContext) (IStep, error)
 }

internal/gateway/bootloader/bootloader.go

@@ -0,0 +1 @@
+package cli