Remove time.Ticker and adjust polling mechanism

[pstop.git] / main.go

diff --git a/main.go b/main.go
index b7a6692..927a151 100644 (file)
--- a/main.go
+++ b/main.go
@@ -4,11 +4,14 @@ package main
 
 import (
        "database/sql"
+       "errors"
        "flag"
        "fmt"
        "log"
        "os"
        "os/signal"
+       "regexp"
+       "runtime/pprof"
        "syscall"
        "time"
 
@@ -19,6 +22,7 @@ import (
        "github.com/sjmudd/pstop/lib"
        "github.com/sjmudd/pstop/state"
        "github.com/sjmudd/pstop/version"
+       "github.com/sjmudd/pstop/wait_info"
 )
 
 const (
@@ -26,9 +30,19 @@ const (
        db         = "performance_schema"
 )
 
+var (
+       flag_version = flag.Bool("version", false, "Show the version of "+lib.MyName())
+       flag_debug   = flag.Bool("debug", false, "Enabling debug logging")
+       flag_help    = flag.Bool("help", false, "Provide some help for "+lib.MyName())
+       cpuprofile   = flag.String("cpuprofile", "", "write cpu profile to file")
+
+       re_valid_version = regexp.MustCompile(`^(5\.[67]\.|10\.[01])`)
+)
+
 func get_db_handle() *sql.DB {
        var err error
        var dbh *sql.DB
+       lib.Logger.Println("get_db_handle() connecting to database")
 
        dbh, err = mysql_defaults_file.OpenUsingDefaultsFile(sql_driver, "", "performance_schema")
        if err != nil {
@@ -66,13 +80,57 @@ func usage() {
        fmt.Println("-version   show the version")
 }
 
+// pstop requires MySQL 5.6+ or MariaDB 10.0+. Check the version
+// rather than giving an error message if the requires P_S tables can't
+// be found.
+func validate_mysql_version(dbh *sql.DB) error {
+       var tables = [...]string{
+               "performance_schema.file_summary_by_instance",
+               "performance_schema.table_io_waits_summary_by_table",
+               "performance_schema.table_lock_waits_summary_by_table",
+       }
+
+       lib.Logger.Println("validate_mysql_version()")
+
+       lib.Logger.Println("- Getting MySQL version")
+       err, mysql_version := lib.SelectGlobalVariableByVariableName(dbh, "VERSION")
+       if err != nil {
+               return err
+       }
+       lib.Logger.Println("- mysql_version: '" + mysql_version + "'")
+
+       if !re_valid_version.MatchString(mysql_version) {
+               err := errors.New(lib.MyName() + " does not work with MySQL version " + mysql_version)
+               return err
+       }
+       lib.Logger.Println("OK: MySQL version is valid, continuing")
+
+       lib.Logger.Println("Checking access to required tables:")
+       for i := range tables {
+               if err := lib.CheckTableAccess(dbh, tables[i]); err == nil {
+                       lib.Logger.Println("OK: " + tables[i] + " found")
+               } else {
+                       return err
+               }
+       }
+       lib.Logger.Println("OK: all table checks passed")
+
+       return nil
+}
+
 func main() {
-       var flag_version = flag.Bool("version", false, "Show the version of "+lib.MyName())
-       var flag_debug = flag.Bool("debug", false, "Enabling debug logging")
-       var flag_help = flag.Bool("help", false, "Provide some help for "+lib.MyName())
        flag.Parse()
 
        // clean me up
+       if *cpuprofile != "" {
+               f, err := os.Create(*cpuprofile)
+               if err != nil {
+                       log.Fatal(err)
+               }
+               pprof.StartCPUProfile(f)
+               defer pprof.StopCPUProfile()
+       }
+
        if *flag_debug {
                lib.Logger.EnableLogging(true)
        }
@@ -86,9 +144,16 @@ func main() {
        }
 
        lib.Logger.Println("Starting " + lib.MyName())
+
+       dbh := get_db_handle()
+       if err := validate_mysql_version(dbh); err != nil {
+               log.Fatal(err)
+       }
+
        var state state.State
+       var wi wait_info.WaitInfo
+       wi.SetWaitInterval(time.Second)
 
-       interval := time.Second
        sigChan := make(chan os.Signal, 1)
        done := make(chan struct{})
        defer close(done)
@@ -96,9 +161,7 @@ func main() {
 
        signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
 
-       ticker := time.NewTicker(interval) // generate a periodic signal
-
-       state.Setup(get_db_handle())
+       state.Setup(dbh)
 
        finished := false
        for !finished {
@@ -109,7 +172,9 @@ func main() {
                case sig := <-sigChan:
                        fmt.Println("Caught a signal", sig)
                        done <- struct{}{}
-               case <-ticker.C:
+               case <-wi.WaitNextPeriod():
+                       state.Collect()
+                       wi.CollectedNow()
                        state.Display()
                case event := <-termboxChan:
                        // switch on event type
@@ -120,35 +185,34 @@ func main() {
                                        finished = true
                                case termbox.KeyTab: // tab - change display modes
                                        state.DisplayNext()
+                                       state.Display()
                                }
                                switch event.Ch {
                                case '-': // decrease the interval if > 1
-                                       if interval > time.Second {
-                                               ticker.Stop()
-                                               interval -= time.Second
-                                               ticker = time.NewTicker(interval)
+                                       if wi.WaitInterval() > time.Second {
+                                               wi.SetWaitInterval(wi.WaitInterval() - time.Second)
                                        }
                                case '+': // increase interval by creating a new ticker
-                                       ticker.Stop()
-                                       interval += time.Second
-                                       ticker = time.NewTicker(interval)
+                                       wi.SetWaitInterval(wi.WaitInterval() + time.Second)
                                case 'h': // help
                                        state.SetHelp(!state.Help())
                                case 'q': // quit
                                        finished = true
                                case 't': // toggle between absolute/relative statistics
                                        state.SetWantRelativeStats(!state.WantRelativeStats())
+                                       state.Display()
                                case 'z': // reset the statistics to now by taking a query of current values
                                        state.ResetDBStatistics()
+                                       state.Display()
                                }
                        case termbox.EventResize: // set sizes
                                state.ScreenSetSize(event.Width, event.Height)
+                               state.Display()
                        case termbox.EventError: // quit
                                log.Fatalf("Quitting because of termbox error: \n%s\n", event.Err)
                        }
                }
        }
        state.Cleanup()
-       ticker.Stop()
        lib.Logger.Println("Terminating " + lib.MyName())
 }