switch to plans

Author: billgraziano

.gitignore

@@ -25,5 +25,6 @@ go.work.sum
 # popmaint
 /log
 /state
+/plans
 *.json
 

README.md

@@ -45,24 +45,6 @@ plan1.toml
 plan2.toml
 ```
 
-
-
-Storing State
--------------
-* State needs to support all actions
-* Need to handle read-only databases
-* Need to handle databases that come and go
-* State struct
-    * Key(domain, computer, instance, database) 
-    * Value: last DBCC, last dbcc settings, last seen
-    * Saved in `./state/plan1.state.json`
-* Maybe a state log that stores each event.  But it will get big.  Maybe compress on startup.
-* Read in the state and update it as we go.  Write with each update.
-* DBCCEngine
-    DBCCState - struct that holds all the DBCC we have done
-    CheckDB(...)
-
-
 Finding Work
 ------------
 * Get all the databases
@@ -87,11 +69,6 @@ Fun Stuff
 * Write sql.Rows to a log file
 * Write the log file and rotate it
 
-Read-Only Databases
--------------------
-* Need to store state with the executable
-* Write a 
-
 Next Test #1
 ------------
 * Monitor for blocking or blocked by and abort (EXECMON)

cmd/checkdb/main.go

@@ -1,41 +1,35 @@
 package main
 
 import (
-	"context"
 	"flag"
 	"log"
+	"os"
 	"popmaint/pkg/app"
-	"popmaint/pkg/maint"
-	"popmaint/pkg/state"
 )
 
 func main() {
-	out := app.OutWriter{}
-	ctx := context.Background()
-	do := maint.CheckDBOptions{}
-	var fqdn string
 
-	flag.BoolVar(&do.NoIndex, "noindex", false, "Set the NOINDEX option")
-	flag.BoolVar(&do.InfoMessage, "messages", false, "Display Info Messages (disable NO_INFOMSGS)")
-	flag.BoolVar(&do.PhysicalOnly, "physical_only", false, "Set the PHYSICAL_ONLY option")
-	flag.IntVar(&do.MaxSizeMB, "max_size", 0, "max database size to check (MB)")
-	flag.StringVar(&fqdn, "fqdn", "", "server to run against")
-	flag.BoolVar(&do.NoExec, "noexec", false, "do not execute the DBCC")
+	//ctx := context.Background()
+	//do := maint.CheckDBOptions{}
+	var plan string
+	var noexec bool
+	// flag.BoolVar(&do.NoIndex, "noindex", false, "Set the NOINDEX option")
+	// flag.BoolVar(&do.InfoMessage, "messages", false, "Display Info Messages (disable NO_INFOMSGS)")
+	// flag.BoolVar(&do.PhysicalOnly, "physical_only", false, "Set the PHYSICAL_ONLY option")
+	// flag.IntVar(&do.MaxSizeMB, "max_size", 0, "max database size to check (MB)")
+	flag.StringVar(&plan, "plan", "", "plan to run")
+	flag.BoolVar(&noexec, "noexec", false, "do not execute the DBCC (display only)")
 	flag.Parse()
-	if fqdn == "" {
-		log.Fatal("fatal: --fqdn is required")
+	if plan == "" {
+		log.Fatal("fatal: --plan is required")
 		return
 	}
-	// log settings:
-	out.WriteStringf("host: %s  noindex: %t  messages: %t  physical_only: %t  max_size: %d", fqdn, do.NoIndex, do.InfoMessage, do.PhysicalOnly, do.MaxSizeMB)
-	st, err := state.NewState("Plan1")
-	if err != nil {
-		out.WriteError(err)
-		return
+	exitCode := app.Run(plan, noexec)
+	if exitCode > 125 {
+		exitCode = 125
 	}
-	ce := app.NewCheckDBEngine(&out, st, do)
-	err = ce.CheckDB(ctx, fqdn)
-	if err != nil {
-		out.WriteError(err)
+	if exitCode < 0 {
+		exitCode = 0
 	}
+	os.Exit(exitCode)
 }

go.mod

@@ -7,13 +7,13 @@ require (
 	github.com/golang-sql/sqlexp v0.1.0
 	github.com/jmoiron/sqlx v1.4.0
 	github.com/microsoft/go-mssqldb v1.7.2
+	github.com/pelletier/go-toml/v2 v2.2.2
+	github.com/pkg/errors v0.9.1
 )
 
 require (
 	github.com/golang-sql/civil v0.0.0-20220223132316-b832511892a9 // indirect
-	github.com/pkg/errors v0.9.1 // indirect
 	github.com/spf13/afero v1.9.5 // indirect
-	github.com/stretchr/testify v1.9.0 // indirect
 	golang.org/x/crypto v0.18.0 // indirect
 	golang.org/x/sys v0.16.0 // indirect
 	golang.org/x/text v0.14.0 // indirect

go.sum

@@ -163,6 +163,8 @@ github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o
 github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
 github.com/microsoft/go-mssqldb v1.7.2 h1:CHkFJiObW7ItKTJfHo1QX7QBBD1iV+mn1eOyRP3b/PA=
 github.com/microsoft/go-mssqldb v1.7.2/go.mod h1:kOvZKUdrhhFQmxLZqbwUV0rHkNkZpthMITIb2Ko1IoA=
+github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM=
+github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs=
 github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ=
 github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
@@ -175,9 +177,15 @@ github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFR
 github.com/spf13/afero v1.9.5 h1:stMpOSZFs//0Lv29HduCmli3GUfpFoF3Y1Q/aXj/wVM=
 github.com/spf13/afero v1.9.5/go.mod h1:UBogFpq8E9Hx+xc5CNTTEpTnuHVmXDwZcZcE1eb/UhQ=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=

pkg/app/app.go

@@ -0,0 +1,35 @@
+package app
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"popmaint/pkg/config.go"
+	"popmaint/pkg/state"
+)
+
+var ErrRunError = errors.New("error running plan")
+
+func Run(planName string, noexec bool) int {
+	ctx := context.Background()
+	out := OutWriter{}
+	plan, err := config.ReadPlan(planName)
+	if err != nil {
+		out.WriteError(err)
+		return 1
+	}
+	out.WriteStringf("%s: servers: %d  noexec: %t", planName, len(plan.Servers), noexec)
+	st, err := state.NewState(planName)
+	if err != nil {
+		out.WriteError(err)
+		return 1
+	}
+	defer func(st *state.State) {
+		if err := st.Close(); err != nil {
+			out.WriteError(fmt.Errorf("state.close: %w", err))
+		}
+	}(st)
+
+	engine := NewEngine(&out, st)
+	return engine.runPlan(ctx, plan, noexec)
+}

pkg/app/checkdb.go

@@ -2,79 +2,154 @@ package app
 
 import (
 	"context"
+	"popmaint/pkg/config.go"
 	"popmaint/pkg/maint"
 	"popmaint/pkg/mssqlz"
 	"popmaint/pkg/state"
 	"sort"
+	"time"
 
-	"github.com/billgraziano/mssqlh"
+	"github.com/pkg/errors"
 )
 
-type CheckDBEngine struct {
-	out mssqlz.Outputer
-	do  maint.CheckDBOptions
-	st  *state.State
+type Engine struct {
+	out   mssqlz.Outputer
+	st    *state.State
+	start time.Time
 }
 
-func NewCheckDBEngine(out mssqlz.Outputer, st *state.State, do maint.CheckDBOptions) CheckDBEngine {
-	return CheckDBEngine{
-		out: out,
-		do:  do,
-		st:  st,
+func NewEngine(out mssqlz.Outputer, st *state.State) Engine {
+	return Engine{
+		out:   out,
+		st:    st,
+		start: time.Now(),
 	}
 }
 
-func (ce *CheckDBEngine) CheckDB(ctx context.Context, host string) error {
-	pool, err := mssqlh.Open(host, "master")
-	if err != nil {
-		return err
-	}
-	defer pool.Close()
+func (engine *Engine) runPlan(ctx context.Context, plan config.Plan, noexec bool) int {
+	// TODO sort the plan entries and run in order
+	return engine.runCheckDB(ctx, plan, noexec)
+}
 
-	databases, err := mssqlz.OnlineDatabases(ctx, host)
-	if err != nil {
-		return err
-	}
+func (engine *Engine) runCheckDB(ctx context.Context, plan config.Plan, noexec bool) int {
+	var err error
+	exitCode := 0
+	timeLimit := time.Duration(plan.CheckDB.TimeLimit)
+	start := time.Now()
+	engine.out.WriteStringf("%s: checkdb: time_limit: %s  noindex: %t  physical_only: %t  max_size_mb: %d  info_messages: %t", plan.Name, timeLimit, plan.CheckDB.NoIndex, plan.CheckDB.PhysicalOnly, plan.CheckDB.MaxSizeMB, plan.CheckDB.InfoMessages)
 
-	// Get the last CheckDB date from `state`.
-	// Secondary replicas always report the value from the primary.
-	// That means we will use our date.
+	// loop through all servers and get databases
+	databases := make([]mssqlz.Database, 0)
+	for _, fqdn := range plan.Servers {
+		srv, err := mssqlz.GetServer(ctx, fqdn)
+		if err != nil {
+			engine.out.WriteError(errors.Wrap(err, fqdn))
+			continue
+		}
+		dbs, err := mssqlz.OnlineDatabases(ctx, fqdn)
+		if err != nil {
+			engine.out.WriteError(errors.Wrap(err, fqdn))
+			continue
+		}
+		databases = append(databases, dbs...)
+		engine.out.WriteStringf("fqdn: %s  server: %s  databases: %d", fqdn, srv.ServerName, len(dbs))
+	}
+	// sort the databases, filter, and get state
 	for i, db := range databases {
-		tm, ok := ce.st.GetCheckDB(db)
+		tm, ok := engine.st.GetLastCheckDBDate(db)
 		if ok {
 			databases[i].LastDBCC = tm
 		}
 	}
-
-	// sort the oldest first, and then the largest
 	sort.SliceStable(databases, func(i, j int) bool {
 		if databases[i].LastDBCC.Before(databases[j].LastDBCC) {
 			return true
 		}
 
 		return databases[i].DatabaseMB > databases[j].DatabaseMB
 	})
-
+	// if !noexec, run each one
 	for _, db := range databases {
-		if ce.do.MaxSizeMB > 0 && db.DatabaseMB > ce.do.MaxSizeMB {
+		if time.Now().After(start.Add(timeLimit)) {
+			engine.out.WriteStringf("%s: time_limit (%s) exceeded", plan.Name, timeLimit)
+			break
+		}
+		if plan.CheckDB.MaxSizeMB > 0 && db.DatabaseMB > plan.CheckDB.MaxSizeMB {
 			continue
 		}
-		err = maint.CheckDB(ctx, ce.out, host, db, ce.do)
+		engine.out.WriteStringf("%s: database: %s  size_mb: %d  last_dbcc: %s", db.ServerName, db.DatabaseName, db.DatabaseMB, db.LastDBCC.Format("2006-01-02 15:04:05"))
+
+		err = maint.CheckDB(ctx, engine.out, db.FQDN, db, plan, noexec)
 		if err != nil {
-			// TODO keep going on error?
-			return err
+			// Log the error and keep going
+			exitCode = 1
+			engine.out.WriteErrorf("%s: %s", db.ServerName, err.Error())
+			continue // don't set the state
 		}
-		if !ce.do.NoExec { // if we really did it, save it
-			err = ce.st.SaveCheckDB(db)
+		if !noexec { // if we really did it, save it
+			err = engine.st.SetLastCheckDBDate(db)
 			if err != nil {
-				ce.out.WriteError(err)
-				return err
+				engine.out.WriteError(err)
+				exitCode = 1
 			}
+			// TODO Log the run time for this: FQDN, server, database, size, duration (rounded to second)
 		}
 	}
-	return nil
+	return exitCode
 }
 
+// // TODO: CheckDB only checks one mssqlz.Database row and writes the results
+// func (ce *Engine) CheckDB(ctx context.Context, host string, plan config.Plan, noexec bool) error {
+// 	pool, err := mssqlh.Open(host, "master")
+// 	if err != nil {
+// 		return err
+// 	}
+// 	defer pool.Close()
+
+// 	databases, err := mssqlz.OnlineDatabases(ctx, host)
+// 	if err != nil {
+// 		return err
+// 	}
+
+// 	// Get the last CheckDB date from `state`.
+// 	// Secondary replicas always report the value from the primary.
+// 	// That means we will use our date.
+// 	for i, db := range databases {
+// 		tm, ok := ce.st.GetLastCheckDBDate(db)
+// 		if ok {
+// 			databases[i].LastDBCC = tm
+// 		}
+// 	}
+
+// 	// sort the oldest first, and then the largest
+// 	sort.SliceStable(databases, func(i, j int) bool {
+// 		if databases[i].LastDBCC.Before(databases[j].LastDBCC) {
+// 			return true
+// 		}
+
+// 		return databases[i].DatabaseMB > databases[j].DatabaseMB
+// 	})
+
+// 	for _, db := range databases {
+// 		if plan.CheckDB.MaxSizeMB > 0 && db.DatabaseMB > plan.CheckDB.MaxSizeMB {
+// 			continue
+// 		}
+// 		err = maint.CheckDB(ctx, ce.out, host, db, plan, noexec)
+// 		if err != nil {
+// 			// TODO keep going on error?
+// 			return err
+// 		}
+// 		if !noexec { // if we really did it, save it
+// 			err = ce.st.SetLastCheckDBDate(db)
+// 			if err != nil {
+// 				ce.out.WriteError(err)
+// 				return err
+// 			}
+// 		}
+// 	}
+// 	return nil
+// }
+
 // // sort by oldest defrag, then largest size
 // func sortDatabases(databases []mssqlz.Database) {
 // 	sort.SliceStable(databases, func(i, j int) bool {

pkg/app/outwriter.go

@@ -51,6 +51,11 @@ func (ow *OutWriter) WriteError(err error) error {
 	return nil
 }
 
+func (ow *OutWriter) WriteErrorf(fmt string, args ...any) error {
+	log.Printf(fmt, args...)
+	return nil
+}
+
 func (ow *OutWriter) WriteRowSet() error {
 	panic("rowset!")
 }