rnsrk/wisski-cloud-distillery
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

pkg/logging: Remove unneeded argument

Browse source
This commit is contained in:
Tom Wiesing 2023-03-13 13:24:19 +01:00
parent d7847b5d69
commit 2493cbb078
No known key found for this signature in database
15 changed files with 75 additions and 76 deletions
Download patch file Download diff file Expand all files Collapse all files

2
cmd/backup.go
View file

@ -42,7 +42,7 @@ func (bk backup) Run(context wisski_distillery.Context) error {
if !bk.NoPrune { if !bk.NoPrune {
defer logging.LogOperation(func() error { defer logging.LogOperation(func() error {
return dis.Exporter().PruneExports(context.Context, context.Stderr) return dis.Exporter().PruneExports(context.Context, context.Stderr)
}, context.Stderr, context.Context, "Pruning old backups") }, context.Stderr, "Pruning old backups")
} }
// do the handling // do the handling

12
cmd/bootstrap.go
View file

@ -80,7 +80,7 @@ func (bs cBootstrap) Run(context wisski_distillery.Context) error {
} }
{ {
logging.LogMessage(context.Stderr, context.Context, "Creating root deployment directory") logging.LogMessage(context.Stderr, "Creating root deployment directory")
if err := fsx.MkdirAll(root, fsx.DefaultDirPerm); err != nil { if err := fsx.MkdirAll(root, fsx.DefaultDirPerm); err != nil {
return errBootstrapFailedToCreateDirectory.WithMessageF(root).Wrap(err) return errBootstrapFailedToCreateDirectory.WithMessageF(root).Wrap(err)
} }
@ -105,7 +105,7 @@ func (bs cBootstrap) Run(context wisski_distillery.Context) error {
} }
{ {
logging.LogMessage(context.Stderr, context.Context, "Copying over wdcli executable") logging.LogMessage(context.Stderr, "Copying over wdcli executable")
exe, err := os.Executable() exe, err := os.Executable()
if err != nil { if err != nil {
return errBoostrapFailedToCopyExe.WithMessageF(err) return errBoostrapFailedToCopyExe.WithMessageF(err)
@ -144,7 +144,7 @@ func (bs cBootstrap) Run(context wisski_distillery.Context) error {
} }
return nil return nil
}, context.Stderr, context.Context, "Creating custom config files"); err != nil { }, context.Stderr, "Creating custom config files"); err != nil {
return errBootstrapCreateFile.Wrap(err) return errBootstrapCreateFile.Wrap(err)
} }
@ -170,7 +170,7 @@ func (bs cBootstrap) Run(context wisski_distillery.Context) error {
_, err := configYML.Write(bytes) _, err := configYML.Write(bytes)
return err return err
} }
}, context.Stderr, context.Context, "Installing primary configuration file"); err != nil { }, context.Stderr, "Installing primary configuration file"); err != nil {
return errBootstrapWriteConfig.Wrap(err) return errBootstrapWriteConfig.Wrap(err)
} }
} }
@ -178,7 +178,7 @@ func (bs cBootstrap) Run(context wisski_distillery.Context) error {
} }
// re-read the configuration and print it! // re-read the configuration and print it!
logging.LogMessage(context.Stderr, context.Context, "Configuration is now complete") logging.LogMessage(context.Stderr, "Configuration is now complete")
f, err := os.Open(cfgPath) f, err := os.Open(cfgPath)
if err != nil { if err != nil {
return errBootstrapOpenConfig.Wrap(err) return errBootstrapOpenConfig.Wrap(err)
@ -192,7 +192,7 @@ func (bs cBootstrap) Run(context wisski_distillery.Context) error {
context.Println(cfg) context.Println(cfg)
// Tell the user how to proceed // Tell the user how to proceed
logging.LogMessage(context.Stderr, context.Context, "Bootstrap is complete") logging.LogMessage(context.Stderr, "Bootstrap is complete")
context.Printf("Adjust the configuration file at %s\n", cfgPath) context.Printf("Adjust the configuration file at %s\n", cfgPath)
context.Printf("Then make sure 'docker compose' is installed.\n") context.Printf("Then make sure 'docker compose' is installed.\n")
context.Printf("Finally grab a GraphDB zipped source file and run:\n") context.Printf("Finally grab a GraphDB zipped source file and run:\n")

12
cmd/monday.go
View file

@ -37,36 +37,36 @@ func (monday monday) AfterParse() error {
func (monday monday) Run(context wisski_distillery.Context) error { func (monday monday) Run(context wisski_distillery.Context) error {
if err := logging.LogOperation(func() error { if err := logging.LogOperation(func() error {
return context.Exec("backup") return context.Exec("backup")
}, context.Stderr, context.Context, "Running backup"); err != nil { }, context.Stderr, "Running backup"); err != nil {
return err return err
} }
if err := logging.LogOperation(func() error { if err := logging.LogOperation(func() error {
return context.Exec("system_update", monday.Positionals.GraphdbZip) return context.Exec("system_update", monday.Positionals.GraphdbZip)
}, context.Stderr, context.Context, "Running system_update"); err != nil { }, context.Stderr, "Running system_update"); err != nil {
return err return err
} }
if err := logging.LogOperation(func() error { if err := logging.LogOperation(func() error {
return context.Exec("rebuild") return context.Exec("rebuild")
}, context.Stderr, context.Context, "Running rebuild"); err != nil { }, context.Stderr, "Running rebuild"); err != nil {
return err return err
} }
if err := logging.LogOperation(func() error { if err := logging.LogOperation(func() error {
return context.Exec("update_prefix_config") return context.Exec("update_prefix_config")
}, context.Stderr, context.Context, "Running update_prefix_config"); err != nil { }, context.Stderr, "Running update_prefix_config"); err != nil {
return err return err
} }
if monday.UpdateInstances { if monday.UpdateInstances {
if err := logging.LogOperation(func() error { if err := logging.LogOperation(func() error {
return context.Exec("blind_update") return context.Exec("blind_update")
}, context.Stderr, context.Context, "Running blind_update"); err != nil { }, context.Stderr, "Running blind_update"); err != nil {
return err return err
} }
} }
logging.LogMessage(context.Stderr, context.Context, "Done, have a great week!") logging.LogMessage(context.Stderr, "Done, have a great week!")
return nil return nil
} }

2
cmd/provision.go
View file

@ -43,7 +43,7 @@ func (p pv) Run(context wisski_distillery.Context) error {
} }
// and we're done! // and we're done!
logging.LogMessage(context.Stderr, context.Context, "Instance has been provisioned") logging.LogMessage(context.Stderr, "Instance has been provisioned")
context.Printf("URL: %s\n", instance.URL().String()) context.Printf("URL: %s\n", instance.URL().String())
context.Printf("Username: %s\n", instance.DrupalUsername) context.Printf("Username: %s\n", instance.DrupalUsername)
context.Printf("Password: %s\n", instance.DrupalPassword) context.Printf("Password: %s\n", instance.DrupalPassword)

10
cmd/reserve.go
View file

@ -47,7 +47,7 @@ func (r reserve) Run(context wisski_distillery.Context) (err error) {
slug := r.Positionals.Slug slug := r.Positionals.Slug
// check that it doesn't already exist // check that it doesn't already exist
logging.LogMessage(context.Stderr, context.Context, "Reserving new WissKI instance %s", slug) logging.LogMessage(context.Stderr, "Reserving new WissKI instance %s", slug)
if exists, err := dis.Instances().Has(context.Context, slug); err != nil || exists { if exists, err := dis.Instances().Has(context.Context, slug); err != nil || exists {
return errReserveAlreadyExists.WithMessageF(slug) return errReserveAlreadyExists.WithMessageF(slug)
} }
@ -59,7 +59,7 @@ func (r reserve) Run(context wisski_distillery.Context) (err error) {
} }
// check that the base directory does not exist // check that the base directory does not exist
logging.LogMessage(context.Stderr, context.Context, "Checking that base directory %s does not exist", instance.FilesystemBase) logging.LogMessage(context.Stderr, "Checking that base directory %s does not exist", instance.FilesystemBase)
if fsx.IsDirectory(instance.FilesystemBase) { if fsx.IsDirectory(instance.FilesystemBase) {
return errReserveAlreadyExists.WithMessageF(slug) return errReserveAlreadyExists.WithMessageF(slug)
} }
@ -69,19 +69,19 @@ func (r reserve) Run(context wisski_distillery.Context) (err error) {
{ {
if err := logging.LogOperation(func() error { if err := logging.LogOperation(func() error {
return s.Install(context.Context, context.Stderr, component.InstallationContext{}) return s.Install(context.Context, context.Stderr, component.InstallationContext{})
}, context.Stderr, context.Context, "Installing docker stack"); err != nil { }, context.Stderr, "Installing docker stack"); err != nil {
return err return err
} }
if err := logging.LogOperation(func() error { if err := logging.LogOperation(func() error {
return s.Update(context.Context, context.Stderr, true) return s.Update(context.Context, context.Stderr, true)
}, context.Stderr, context.Context, "Updating docker stack"); err != nil { }, context.Stderr, "Updating docker stack"); err != nil {
return err return err
} }
} }
// and we're done! // and we're done!
logging.LogMessage(context.Stderr, context.Context, "Instance has been reserved") logging.LogMessage(context.Stderr, "Instance has been reserved")
context.Printf("URL: %s\n", instance.URL().String()) context.Printf("URL: %s\n", instance.URL().String())
return nil return nil

8
cmd/system_pause.go
View file

@ -60,7 +60,7 @@ func (sp systempause) Run(context wisski_distillery.Context) (err error) {
} }
func (sp systempause) start(context wisski_distillery.Context, dis *dis.Distillery) error { func (sp systempause) start(context wisski_distillery.Context, dis *dis.Distillery) error {
logging.LogMessage(context.Stderr, context.Context, "Starting Components") logging.LogMessage(context.Stderr, "Starting Components")
// find all the core stacks // find all the core stacks
if err := status.RunErrorGroup(context.Stderr, status.Group[component.Installable, error]{ if err := status.RunErrorGroup(context.Stderr, status.Group[component.Installable, error]{
@ -76,7 +76,7 @@ func (sp systempause) start(context wisski_distillery.Context, dis *dis.Distille
return err return err
} }
logging.LogMessage(context.Stderr, context.Context, "Starting Up WissKIs") logging.LogMessage(context.Stderr, "Starting Up WissKIs")
// find the instances // find the instances
wissKIs, err := dis.Instances().All(context.Context) wissKIs, err := dis.Instances().All(context.Context)
@ -102,7 +102,7 @@ func (sp systempause) start(context wisski_distillery.Context, dis *dis.Distille
} }
func (sp systempause) stop(context wisski_distillery.Context, dis *dis.Distillery) error { func (sp systempause) stop(context wisski_distillery.Context, dis *dis.Distillery) error {
logging.LogMessage(context.Stderr, context.Context, "Shutting Down WissKIs") logging.LogMessage(context.Stderr, "Shutting Down WissKIs")
// find the instances // find the instances
wissKIs, err := dis.Instances().All(context.Context) wissKIs, err := dis.Instances().All(context.Context)
@ -124,7 +124,7 @@ func (sp systempause) stop(context wisski_distillery.Context, dis *dis.Distiller
return err return err
} }
logging.LogMessage(context.Stderr, context.Context, "Shutting Down Components") logging.LogMessage(context.Stderr, "Shutting Down Components")
// find all the core stacks // find all the core stacks
if err := status.RunErrorGroup(context.Stderr, status.Group[component.Installable, error]{ if err := status.RunErrorGroup(context.Stderr, status.Group[component.Installable, error]{

20
cmd/system_update.go
View file

@ -83,7 +83,7 @@ func (si systemupdate) Run(context wisski_distillery.Context) (err error) {
dis := context.Environment dis := context.Environment
// create all the other directories // create all the other directories
logging.LogMessage(context.Stderr, context.Context, "Ensuring distillery installation directories exist") logging.LogMessage(context.Stderr, "Ensuring distillery installation directories exist")
for _, d := range []string{ for _, d := range []string{
dis.Config.Paths.Root, dis.Config.Paths.Root,
dis.Instances().Path(), dis.Instances().Path(),
@ -99,7 +99,7 @@ func (si systemupdate) Run(context wisski_distillery.Context) (err error) {
if si.InstallDocker { if si.InstallDocker {
// install system updates // install system updates
logging.LogMessage(context.Stderr, context.Context, "Updating Operating System Packages") logging.LogMessage(context.Stderr, "Updating Operating System Packages")
if err := si.mustExec(context, "", "apt-get", "update"); err != nil { if err := si.mustExec(context, "", "apt-get", "update"); err != nil {
return err return err
} }
@ -108,7 +108,7 @@ func (si systemupdate) Run(context wisski_distillery.Context) (err error) {
} }
// install docker // install docker
logging.LogMessage(context.Stderr, context.Context, "Installing / Updating Docker") logging.LogMessage(context.Stderr, "Installing / Updating Docker")
if err := si.mustExec(context, "", "apt-get", "install", "curl"); err != nil { if err := si.mustExec(context, "", "apt-get", "install", "curl"); err != nil {
return err return err
} }
@ -120,7 +120,7 @@ func (si systemupdate) Run(context wisski_distillery.Context) (err error) {
// check that the docker api is available // check that the docker api is available
{ {
logging.LogMessage(context.Stderr, context.Context, "Checking that the 'docker' api is reachable") logging.LogMessage(context.Stderr, "Checking that the 'docker' api is reachable")
ping, err := dis.Docker().Ping(context.Context) ping, err := dis.Docker().Ping(context.Context)
if err != nil { if err != nil {
return errDockerUnreachable.Wrap(err) return errDockerUnreachable.Wrap(err)
@ -129,7 +129,7 @@ func (si systemupdate) Run(context wisski_distillery.Context) (err error) {
} }
{ {
logging.LogMessage(context.Stderr, context.Context, "Checking that 'docker compose' is available") logging.LogMessage(context.Stderr, "Checking that 'docker compose' is available")
if err := si.mustExec(context, "", "docker", "compose", "version"); err != nil { if err := si.mustExec(context, "", "docker", "compose", "version"); err != nil {
return err return err
} }
@ -137,7 +137,7 @@ func (si systemupdate) Run(context wisski_distillery.Context) (err error) {
// create the docker networks // create the docker networks
{ {
logging.LogMessage(context.Stderr, context.Context, "Configuring docker networks") logging.LogMessage(context.Stderr, "Configuring docker networks")
for _, name := range dis.Config.Docker.Networks() { for _, name := range dis.Config.Docker.Networks() {
id, existed, err := dis.Docker().CreateNetwork(context.Context, name) id, existed, err := dis.Docker().CreateNetwork(context.Context, name)
@ -192,7 +192,7 @@ func (si systemupdate) Run(context wisski_distillery.Context) (err error) {
return ud.Update(context.Context, writer) return ud.Update(context.Context, writer)
}, },
}, dis.Installable()) }, dis.Installable())
}, context.Stderr, context.Context, "Performing Stack Updates"); err != nil { }, context.Stderr, "Performing Stack Updates"); err != nil {
return err return err
} }
@ -206,17 +206,17 @@ func (si systemupdate) Run(context wisski_distillery.Context) (err error) {
return nil return nil
} }
return item.Update(context.Context, context.Stderr) return item.Update(context.Context, context.Stderr)
}, context.Stderr, context.Context, "Updating Component: %s", name); err != nil { }, context.Stderr, "Updating Component: %s", name); err != nil {
return errBootstrapComponent.WithMessageF(name).Wrap(err) return errBootstrapComponent.WithMessageF(name).Wrap(err)
} }
} }
return nil return nil
}, context.Stderr, context.Context, "Performing Component Updates"); err != nil { }, context.Stderr, "Performing Component Updates"); err != nil {
return err return err
} }
// TODO: Register cronjob in /etc/cron.d! // TODO: Register cronjob in /etc/cron.d!
logging.LogMessage(context.Stderr, context.Context, "System has been updated") logging.LogMessage(context.Stderr, "System has been updated")
return nil return nil
} }

6
internal/dis/component/exporter/backup.go
View file

@ -64,7 +64,7 @@ func (exporter *Exporter) NewBackup(ctx context.Context, progress io.Writer, des
backup.EndTime = time.Now().UTC() backup.EndTime = time.Now().UTC()
return nil return nil
}, progress, ctx, "Writing backup files") }, progress, "Writing backup files")
return return
} }
@ -109,7 +109,7 @@ func (backup *Backup) run(ctx context.Context, progress io.Writer, exporter *Exp
} }
return nil return nil
}, progress, ctx, "Backing up core components") }, progress, "Backing up core components")
// backup instances // backup instances
logging.LogOperation(func() error { logging.LogOperation(func() error {
@ -164,6 +164,6 @@ func (backup *Backup) run(ctx context.Context, progress io.Writer, exporter *Exp
}) })
return nil return nil
}, progress, ctx, "Creating instance snapshots") }, progress, "Creating instance snapshots")
} }

12
internal/dis/component/exporter/iface.go
View file

@ -56,7 +56,7 @@ func (exporter *Exporter) MakeExport(ctx context.Context, progress io.Writer, ta
} }
// determine target paths // determine target paths
logging.LogMessage(progress, ctx, "Determining target paths") logging.LogMessage(progress, "Determining target paths")
var stagingDir, archivePath string var stagingDir, archivePath string
if task.StagingOnly { if task.StagingOnly {
stagingDir = task.Dest stagingDir = task.Dest
@ -76,7 +76,7 @@ func (exporter *Exporter) MakeExport(ctx context.Context, progress io.Writer, ta
fmt.Fprintf(progress, "Archive Path: %s\n", archivePath) fmt.Fprintf(progress, "Archive Path: %s\n", archivePath)
// create the staging directory // create the staging directory
logging.LogMessage(progress, ctx, "Creating staging directory") logging.LogMessage(progress, "Creating staging directory")
err = fsx.Mkdir(stagingDir, fsx.DefaultDirPerm) err = fsx.Mkdir(stagingDir, fsx.DefaultDirPerm)
if !errors.Is(err, fs.ErrExist) && err != nil { if !errors.Is(err, fs.ErrExist) && err != nil {
return err return err
@ -86,7 +86,7 @@ func (exporter *Exporter) MakeExport(ctx context.Context, progress io.Writer, ta
// we need the staging directory to be deleted at the end // we need the staging directory to be deleted at the end
if !task.StagingOnly { if !task.StagingOnly {
defer func() { defer func() {
logging.LogMessage(progress, ctx, "Removing staging directory") logging.LogMessage(progress, "Removing staging directory")
os.RemoveAll(stagingDir) os.RemoveAll(stagingDir)
}() }()
} }
@ -125,7 +125,7 @@ func (exporter *Exporter) MakeExport(ctx context.Context, progress io.Writer, ta
_, err := sl.Report(report) _, err := sl.Report(report)
return err return err
} }
}, progress, ctx, "Generating %s", Title) }, progress, "Generating %s", Title)
// if we only requested staging // if we only requested staging
// all that is left is to write the log entry // all that is left is to write the log entry
@ -155,12 +155,12 @@ func (exporter *Exporter) MakeExport(ctx context.Context, progress io.Writer, ta
}) })
return err return err
}, progress, ctx, "Writing archive"); err != nil { }, progress, "Writing archive"); err != nil {
return err return err
} }
// write out the log entry // write out the log entry
logging.LogMessage(progress, ctx, "Writing Log Entry") logging.LogMessage(progress, "Writing Log Entry")
entry.Path = archivePath entry.Path = archivePath
entry.Packed = true entry.Packed = true
exporter.Dependencies.ExporterLogger.Add(ctx, entry) exporter.Dependencies.ExporterLogger.Add(ctx, entry)

10
internal/dis/component/exporter/snapshot.go
View file

@ -46,7 +46,7 @@ type Snapshot struct {
// Snapshot creates a new snapshot of this instance into dest // Snapshot creates a new snapshot of this instance into dest
func (snapshots *Exporter) NewSnapshot(ctx context.Context, instance *wisski.WissKI, progress io.Writer, desc SnapshotDescription) (snapshot Snapshot) { func (snapshots *Exporter) NewSnapshot(ctx context.Context, instance *wisski.WissKI, progress io.Writer, desc SnapshotDescription) (snapshot Snapshot) {
logging.LogMessage(progress, ctx, "Locking instance") logging.LogMessage(progress, "Locking instance")
if !instance.Locker().TryLock(ctx) { if !instance.Locker().TryLock(ctx) {
err := locker.Locked err := locker.Locked
fmt.Fprintln(progress, err) fmt.Fprintln(progress, err)
@ -57,7 +57,7 @@ func (snapshots *Exporter) NewSnapshot(ctx context.Context, instance *wisski.Wis
} }
} }
defer func() { defer func() {
logging.LogMessage(progress, ctx, "Unlocking instance") logging.LogMessage(progress, "Unlocking instance")
instance.Locker().Unlock(ctx) instance.Locker().Unlock(ctx)
}() }()
@ -79,7 +79,7 @@ func (snapshots *Exporter) NewSnapshot(ctx context.Context, instance *wisski.Wis
snapshot.EndTime = time.Now().UTC() snapshot.EndTime = time.Now().UTC()
return nil return nil
}, progress, ctx, "Writing snapshot files") }, progress, "Writing snapshot files")
slices.Sort(snapshot.Manifest) slices.Sort(snapshot.Manifest)
return return
@ -89,11 +89,11 @@ func (snapshot *Snapshot) makeParts(ctx context.Context, progress io.Writer, sna
if !needsRunning && !snapshot.Description.Keepalive { if !needsRunning && !snapshot.Description.Keepalive {
stack := instance.Barrel().Stack() stack := instance.Barrel().Stack()
logging.LogMessage(progress, ctx, "Stopping instance") logging.LogMessage(progress, "Stopping instance")
snapshot.ErrStop = stack.Down(ctx, progress) snapshot.ErrStop = stack.Down(ctx, progress)
defer func() { defer func() {
logging.LogMessage(progress, ctx, "Starting instance") logging.LogMessage(progress, "Starting instance")
snapshot.ErrStart = stack.Up(ctx, progress) snapshot.ErrStart = stack.Up(ctx, progress)
}() }()
} }

14
internal/dis/component/instances/purger/purger.go
View file

@ -33,7 +33,7 @@ var errPurgeGeneric = exit.Error{
// Purge permanently purges an instance from the distillery. // Purge permanently purges an instance from the distillery.
// The instance does not have to exist; in which case the resources are also deleted. // The instance does not have to exist; in which case the resources are also deleted.
func (purger *Purger) Purge(ctx context.Context, out io.Writer, slug string) error { func (purger *Purger) Purge(ctx context.Context, out io.Writer, slug string) error {
logging.LogMessage(out, ctx, "Checking bookkeeping table") logging.LogMessage(out, "Checking bookkeeping table")
instance, err := purger.Dependencies.Instances.WissKI(ctx, slug) instance, err := purger.Dependencies.Instances.WissKI(ctx, slug)
if err == instances.ErrWissKINotFound { if err == instances.ErrWissKINotFound {
fmt.Fprintln(out, "Not found in bookkeeping table, assuming defaults") fmt.Fprintln(out, "Not found in bookkeeping table, assuming defaults")
@ -44,13 +44,13 @@ func (purger *Purger) Purge(ctx context.Context, out io.Writer, slug string) err
} }
// remove docker stack // remove docker stack
logging.LogMessage(out, ctx, "Stopping and removing docker container") logging.LogMessage(out, "Stopping and removing docker container")
if err := instance.Barrel().Stack().Down(ctx, out); err != nil { if err := instance.Barrel().Stack().Down(ctx, out); err != nil {
fmt.Fprintln(out, err) fmt.Fprintln(out, err)
} }
// remove the filesystem // remove the filesystem
logging.LogMessage(out, ctx, "Removing from filesystem %s", instance.FilesystemBase) logging.LogMessage(out, "Removing from filesystem %s", instance.FilesystemBase)
if err := os.RemoveAll(instance.FilesystemBase); err != nil { if err := os.RemoveAll(instance.FilesystemBase); err != nil {
fmt.Fprintln(out, err) fmt.Fprintln(out, err)
} }
@ -59,7 +59,7 @@ func (purger *Purger) Purge(ctx context.Context, out io.Writer, slug string) err
if err := logging.LogOperation(func() error { if err := logging.LogOperation(func() error {
domain := instance.Domain() domain := instance.Domain()
for _, pc := range purger.Dependencies.Provisionable { for _, pc := range purger.Dependencies.Provisionable {
logging.LogMessage(out, ctx, "Purging %s resources", pc.Name()) logging.LogMessage(out, "Purging %s resources", pc.Name())
err := pc.Purge(ctx, instance.Instance, domain) err := pc.Purge(ctx, instance.Instance, domain)
if err != nil { if err != nil {
return err return err
@ -67,18 +67,18 @@ func (purger *Purger) Purge(ctx context.Context, out io.Writer, slug string) err
} }
return nil return nil
}, out, ctx, "Purging instance-specific resources"); err != nil { }, out, "Purging instance-specific resources"); err != nil {
return errPurgeGeneric.WithMessageF(slug, err) return errPurgeGeneric.WithMessageF(slug, err)
} }
// remove from bookkeeping // remove from bookkeeping
logging.LogMessage(out, ctx, "Removing instance from bookkeeping") logging.LogMessage(out, "Removing instance from bookkeeping")
if err := instance.Bookkeeping().Delete(ctx); err != nil { if err := instance.Bookkeeping().Delete(ctx); err != nil {
fmt.Fprintln(out, err) fmt.Fprintln(out, err)
} }
// remove the filesystem // remove the filesystem
logging.LogMessage(out, ctx, "Remove lock data") logging.LogMessage(out, "Remove lock data")
if instance.Locker().TryUnlock(ctx) { if instance.Locker().TryUnlock(ctx) {
fmt.Fprintln(out, "instance was not locked") fmt.Fprintln(out, "instance was not locked")
} }

14
internal/dis/component/provision/provision.go
View file

@ -30,7 +30,7 @@ var ErrInstanceAlreadyExists = errors.New("instance with provided slug already e
// Provision provisions a new docker compose instance. // Provision provisions a new docker compose instance.
func (pv *Provision) Provision(progress io.Writer, ctx context.Context, flags ProvisionFlags) (*wisski.WissKI, error) { func (pv *Provision) Provision(progress io.Writer, ctx context.Context, flags ProvisionFlags) (*wisski.WissKI, error) {
// check that it doesn't already exist // check that it doesn't already exist
logging.LogMessage(progress, ctx, "Provisioning new WissKI instance %s", flags.Slug) logging.LogMessage(progress, "Provisioning new WissKI instance %s", flags.Slug)
if exists, err := pv.Dependencies.Instances.Has(ctx, flags.Slug); err != nil || exists { if exists, err := pv.Dependencies.Instances.Has(ctx, flags.Slug); err != nil || exists {
return nil, ErrInstanceAlreadyExists return nil, ErrInstanceAlreadyExists
} }
@ -42,7 +42,7 @@ func (pv *Provision) Provision(progress io.Writer, ctx context.Context, flags Pr
} }
// check that the base directory does not exist // check that the base directory does not exist
logging.LogMessage(progress, ctx, "Checking that base directory %s does not exist", instance.FilesystemBase) logging.LogMessage(progress, "Checking that base directory %s does not exist", instance.FilesystemBase)
if fsx.IsDirectory(instance.FilesystemBase) { if fsx.IsDirectory(instance.FilesystemBase) {
return nil, ErrInstanceAlreadyExists return nil, ErrInstanceAlreadyExists
} }
@ -54,7 +54,7 @@ func (pv *Provision) Provision(progress io.Writer, ctx context.Context, flags Pr
} }
return nil return nil
}, progress, ctx, "Updating bookkeeping database"); err != nil { }, progress, "Updating bookkeeping database"); err != nil {
return nil, err return nil, err
} }
@ -62,7 +62,7 @@ func (pv *Provision) Provision(progress io.Writer, ctx context.Context, flags Pr
if err := logging.LogOperation(func() error { if err := logging.LogOperation(func() error {
domain := instance.Domain() domain := instance.Domain()
for _, pc := range pv.Dependencies.Provisionable { for _, pc := range pv.Dependencies.Provisionable {
logging.LogMessage(progress, ctx, "Provisioning %s resources", pc.Name()) logging.LogMessage(progress, "Provisioning %s resources", pc.Name())
err := pc.Provision(ctx, instance.Instance, domain) err := pc.Provision(ctx, instance.Instance, domain)
if err != nil { if err != nil {
return err return err
@ -70,19 +70,19 @@ func (pv *Provision) Provision(progress io.Writer, ctx context.Context, flags Pr
} }
return nil return nil
}, progress, ctx, "Provisioning instance-specific resources"); err != nil { }, progress, "Provisioning instance-specific resources"); err != nil {
return nil, err return nil, err
} }
// run the provision script // run the provision script
if err := logging.LogOperation(func() error { if err := logging.LogOperation(func() error {
return instance.Provisioner().Provision(ctx, progress) return instance.Provisioner().Provision(ctx, progress)
}, progress, ctx, "Running setup scripts"); err != nil { }, progress, "Running setup scripts"); err != nil {
return nil, err return nil, err
} }
// start the container! // start the container!
logging.LogMessage(progress, ctx, "Starting Container") logging.LogMessage(progress, "Starting Container")
if err := instance.Barrel().Stack().Up(ctx, progress); err != nil { if err := instance.Barrel().Stack().Up(ctx, progress); err != nil {
return nil, err return nil, err
} }

10
internal/dis/component/sql/update.go
View file

@ -52,7 +52,7 @@ func (sql *SQL) Update(ctx context.Context, progress io.Writer) error {
if err := sql.unsafeWaitShell(ctx); err != nil { if err := sql.unsafeWaitShell(ctx); err != nil {
return err return err
} }
logging.LogMessage(progress, ctx, "Creating administrative user") logging.LogMessage(progress, "Creating administrative user")
{ {
username := sql.Config.SQL.AdminUsername username := sql.Config.SQL.AdminUsername
password := sql.Config.SQL.AdminPassword password := sql.Config.SQL.AdminPassword
@ -63,7 +63,7 @@ func (sql *SQL) Update(ctx context.Context, progress io.Writer) error {
} }
// create the admin user // create the admin user
logging.LogMessage(progress, ctx, "Creating sql database") logging.LogMessage(progress, "Creating sql database")
{ {
if !sqlx.IsSafeDatabaseLiteral(sql.Config.SQL.Database) { if !sqlx.IsSafeDatabaseLiteral(sql.Config.SQL.Database) {
return errSQLUnsafeDatabaseName return errSQLUnsafeDatabaseName
@ -75,7 +75,7 @@ func (sql *SQL) Update(ctx context.Context, progress io.Writer) error {
} }
// wait for the database to come up // wait for the database to come up
logging.LogMessage(progress, ctx, "Waiting for database update to be complete") logging.LogMessage(progress, "Waiting for database update to be complete")
if err := sql.WaitQueryTable(ctx); err != nil { if err := sql.WaitQueryTable(ctx); err != nil {
return err return err
} }
@ -84,7 +84,7 @@ func (sql *SQL) Update(ctx context.Context, progress io.Writer) error {
return logging.LogOperation(func() error { return logging.LogOperation(func() error {
for _, table := range sql.Dependencies.Tables { for _, table := range sql.Dependencies.Tables {
info := table.TableInfo() info := table.TableInfo()
logging.LogMessage(progress, ctx, "migrating %q table", table.Name) logging.LogMessage(progress, "migrating %q table", table.Name)
db, err := sql.queryTable(ctx, false, info.Name) db, err := sql.queryTable(ctx, false, info.Name)
if err != nil { if err != nil {
return errSQLUnableToMigrate.WithMessageF(table.Name, "unable to access table") return errSQLUnableToMigrate.WithMessageF(table.Name, "unable to access table")
@ -97,5 +97,5 @@ func (sql *SQL) Update(ctx context.Context, progress io.Writer) error {
} }
} }
return nil return nil
}, progress, ctx, "migrating database tables") }, progress, "migrating database tables")
} }

8
internal/dis/component/triplestore/update.go
View file

@ -13,12 +13,12 @@ import (
var errTriplestoreFailedSecurity = errors.New("failed to enable triplestore security: request did not succeed with HTTP 200 OK") var errTriplestoreFailedSecurity = errors.New("failed to enable triplestore security: request did not succeed with HTTP 200 OK")
func (ts Triplestore) Update(ctx context.Context, progress io.Writer) error { func (ts Triplestore) Update(ctx context.Context, progress io.Writer) error {
logging.LogMessage(progress, ctx, "Waiting for Triplestore") logging.LogMessage(progress, "Waiting for Triplestore")
if err := ts.Wait(ctx); err != nil { if err := ts.Wait(ctx); err != nil {
return err return err
} }
logging.LogMessage(progress, ctx, "Resetting admin user password") logging.LogMessage(progress, "Resetting admin user password")
{ {
res, err := ts.OpenRaw(ctx, "PUT", "/rest/security/users/"+ts.Config.TS.AdminUsername, TriplestoreUserPayload{ res, err := ts.OpenRaw(ctx, "PUT", "/rest/security/users/"+ts.Config.TS.AdminUsername, TriplestoreUserPayload{
Password: ts.Config.TS.AdminPassword, Password: ts.Config.TS.AdminPassword,
@ -43,14 +43,14 @@ func (ts Triplestore) Update(ctx context.Context, progress io.Writer) error {
case http.StatusUnauthorized: case http.StatusUnauthorized:
// a password is needed => security is already enabled. // a password is needed => security is already enabled.
// the password may or may not work, but that's a problem for later // the password may or may not work, but that's a problem for later
logging.LogMessage(progress, ctx, "Security is already enabled") logging.LogMessage(progress, "Security is already enabled")
return nil return nil
default: default:
return fmt.Errorf("failed to create triplestore user: %s", err) return fmt.Errorf("failed to create triplestore user: %s", err)
} }
} }
logging.LogMessage(progress, ctx, "Enabling Triplestore security") logging.LogMessage(progress, "Enabling Triplestore security")
{ {
res, err := ts.OpenRaw(ctx, "POST", "/rest/security", true, "", "") res, err := ts.OpenRaw(ctx, "POST", "/rest/security", true, "", "")
if err != nil { if err != nil {

11
pkg/logging/log.go
View file

@ -1,7 +1,6 @@
package logging package logging
import ( import (
"context"
"fmt" "fmt"
"io" "io"
"strings" "strings"
@ -10,8 +9,8 @@ import (
) )
// LogOperation logs a message that is displayed to the user, and then increases the log indent level. // LogOperation logs a message that is displayed to the user, and then increases the log indent level.
func LogOperation(operation func() error, progress io.Writer, ctx context.Context, format string, args ...interface{}) error { func LogOperation(operation func() error, progress io.Writer, format string, args ...interface{}) error {
logOperation(progress, ctx, getIndent(progress), format, args...) logOperation(progress, getIndent(progress), format, args...)
incIndent(progress) incIndent(progress)
defer decIndent(progress) defer decIndent(progress)
@ -19,11 +18,11 @@ func LogOperation(operation func() error, progress io.Writer, ctx context.Contex
} }
// LogMessage logs a message that is displayed to the user // LogMessage logs a message that is displayed to the user
func LogMessage(progress io.Writer, ctx context.Context, format string, args ...interface{}) (int, error) { func LogMessage(progress io.Writer, format string, args ...interface{}) (int, error) {
return logOperation(progress, ctx, getIndent(progress), format, args...) return logOperation(progress, getIndent(progress), format, args...)
} }
func logOperation(progress io.Writer, ctx context.Context, indent int, format string, args ...interface{}) (int, error) { func logOperation(progress io.Writer, indent int, format string, args ...interface{}) (int, error) {
message := "\033[1m" + strings.Repeat(" ", indent+1) + "=> " + format + "\033[0m\n" message := "\033[1m" + strings.Repeat(" ", indent+1) + "=> " + format + "\033[0m\n"
if !streamIsTerminal(progress) { if !streamIsTerminal(progress) {
message = " => " + format + "\n" message = " => " + format + "\n"