main.go

   1 // pstop - Top like progream which collects information from MySQL's
   2 // performance_schema database.
   3 package main
   4
   5 import (
   6         "database/sql"
   7         "errors"
   8         "flag"
   9         "fmt"
  10         "log"
  11         "os"
  12         "os/signal"
  13         "regexp"
  14         "runtime/pprof"
  15         "syscall"
  16         "time"
  17
  18         _ "github.com/go-sql-driver/mysql"
  19         "github.com/nsf/termbox-go"
  20
  21         "github.com/sjmudd/mysql_defaults_file"
  22         "github.com/sjmudd/pstop/lib"
  23         "github.com/sjmudd/pstop/state"
  24         "github.com/sjmudd/pstop/version"
  25         "github.com/sjmudd/pstop/wait_info"
  26 )
  27
  28 const (
  29         sql_driver = "mysql"
  30         db         = "performance_schema"
  31 )
  32
  33 var (
  34         flag_version = flag.Bool("version", false, "Show the version of "+lib.MyName())
  35         flag_debug   = flag.Bool("debug", false, "Enabling debug logging")
  36         flag_help    = flag.Bool("help", false, "Provide some help for "+lib.MyName())
  37         cpuprofile   = flag.String("cpuprofile", "", "write cpu profile to file")
  38
  39         re_valid_version = regexp.MustCompile(`^(5\.[67]\.|10\.[01])`)
  40 )
  41
  42 func get_db_handle() *sql.DB {
  43         var err error
  44         var dbh *sql.DB
  45         lib.Logger.Println("get_db_handle() connecting to database")
  46
  47         dbh, err = mysql_defaults_file.OpenUsingDefaultsFile(sql_driver, "", "performance_schema")
  48         if err != nil {
  49                 log.Fatal(err)
  50         }
  51         if err = dbh.Ping(); err != nil {
  52                 log.Fatal(err)
  53         }
  54
  55         return dbh
  56 }
  57
  58 // make chan for termbox events and run a poller to send events to the channel
  59 // - return the channel
  60 func new_tb_chan() chan termbox.Event {
  61         termboxChan := make(chan termbox.Event)
  62         go func() {
  63                 for {
  64                         termboxChan <- termbox.PollEvent()
  65                 }
  66         }()
  67         return termboxChan
  68 }
  69
  70 func usage() {
  71         fmt.Println(lib.MyName() + " - " + lib.Copyright())
  72         fmt.Println("")
  73         fmt.Println("Top-like program to show MySQL activity by using information collected")
  74         fmt.Println("from performance_schema.")
  75         fmt.Println("")
  76         fmt.Println("Usage: " + lib.MyName() + " <options>")
  77         fmt.Println("")
  78         fmt.Println("Options:")
  79         fmt.Println("-help      show this help message")
  80         fmt.Println("-version   show the version")
  81 }
  82
  83 // pstop requires MySQL 5.6+ or MariaDB 10.0+. Check the version
  84 // rather than giving an error message if the requires P_S tables can't
  85 // be found.
  86 func validate_mysql_version(dbh *sql.DB) error {
  87         var tables = [...]string{
  88                 "performance_schema.file_summary_by_instance",
  89                 "performance_schema.table_io_waits_summary_by_table",
  90                 "performance_schema.table_lock_waits_summary_by_table",
  91         }
  92
  93         lib.Logger.Println("validate_mysql_version()")
  94
  95         lib.Logger.Println("- Getting MySQL version")
  96         err, mysql_version := lib.SelectGlobalVariableByVariableName(dbh, "VERSION")
  97         if err != nil {
  98                 return err
  99         }
 100         lib.Logger.Println("- mysql_version: '" + mysql_version + "'")
 101
 102         if !re_valid_version.MatchString(mysql_version) {
 103                 err := errors.New(lib.MyName() + " does not work with MySQL version " + mysql_version)
 104                 return err
 105         }
 106         lib.Logger.Println("OK: MySQL version is valid, continuing")
 107
 108         lib.Logger.Println("Checking access to required tables:")
 109         for i := range tables {
 110                 if err := lib.CheckTableAccess(dbh, tables[i]); err == nil {
 111                         lib.Logger.Println("OK: " + tables[i] + " found")
 112                 } else {
 113                         return err
 114                 }
 115         }
 116         lib.Logger.Println("OK: all table checks passed")
 117
 118         return nil
 119 }
 120
 121 func main() {
 122         flag.Parse()
 123
 124         // clean me up
 125         if *cpuprofile != "" {
 126                 f, err := os.Create(*cpuprofile)
 127                 if err != nil {
 128                         log.Fatal(err)
 129                 }
 130                 pprof.StartCPUProfile(f)
 131                 defer pprof.StopCPUProfile()
 132         }
 133
 134         if *flag_debug {
 135                 lib.Logger.EnableLogging(true)
 136         }
 137         if *flag_version {
 138                 fmt.Println(lib.MyName() + " version " + version.Version())
 139                 return
 140         }
 141         if *flag_help {
 142                 usage()
 143                 return
 144         }
 145
 146         lib.Logger.Println("Starting " + lib.MyName())
 147
 148         dbh := get_db_handle()
 149         if err := validate_mysql_version(dbh); err != nil {
 150                 log.Fatal(err)
 151         }
 152
 153         var state state.State
 154         var wi wait_info.WaitInfo
 155         wi.SetWaitInterval(time.Second)
 156
 157         sigChan := make(chan os.Signal, 1)
 158         done := make(chan struct{})
 159         defer close(done)
 160         termboxChan := new_tb_chan()
 161
 162         signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
 163
 164         state.Setup(dbh)
 165
 166         finished := false
 167         for !finished {
 168                 select {
 169                 case <-done:
 170                         fmt.Println("exiting")
 171                         finished = true
 172                 case sig := <-sigChan:
 173                         fmt.Println("Caught a signal", sig)
 174                         done <- struct{}{}
 175                 case <-wi.WaitNextPeriod():
 176                         state.Collect()
 177                         wi.CollectedNow()
 178                         state.Display()
 179                 case event := <-termboxChan:
 180                         // switch on event type
 181                         switch event.Type {
 182                         case termbox.EventKey: // actions depend on key
 183                                 switch event.Key {
 184                                 case termbox.KeyCtrlZ, termbox.KeyCtrlC, termbox.KeyEsc:
 185                                         finished = true
 186                                 case termbox.KeyArrowLeft: // left arrow change to previous display mode
 187                                         state.DisplayPrevious()
 188                                         state.Display()
 189                                 case termbox.KeyTab, termbox.KeyArrowRight: // tab or right arrow - change to next display mode
 190                                         state.DisplayNext()
 191                                         state.Display()
 192                                 }
 193                                 switch event.Ch {
 194                                 case '-': // decrease the interval if > 1
 195                                         if wi.WaitInterval() > time.Second {
 196                                                 wi.SetWaitInterval(wi.WaitInterval() - time.Second)
 197                                         }
 198                                 case '+': // increase interval by creating a new ticker
 199                                         wi.SetWaitInterval(wi.WaitInterval() + time.Second)
 200                                 case 'h': // help
 201                                         state.SetHelp(!state.Help())
 202                                 case 'q': // quit
 203                                         finished = true
 204                                 case 't': // toggle between absolute/relative statistics
 205                                         state.SetWantRelativeStats(!state.WantRelativeStats())
 206                                         state.Display()
 207                                 case 'z': // reset the statistics to now by taking a query of current values
 208                                         state.ResetDBStatistics()
 209                                         state.Display()
 210                                 }
 211                         case termbox.EventResize: // set sizes
 212                                 state.ScreenSetSize(event.Width, event.Height)
 213                                 state.Display()
 214                         case termbox.EventError: // quit
 215                                 log.Fatalf("Quitting because of termbox error: \n%s\n", event.Err)
 216                         }
 217                 }
 218         }
 219         state.Cleanup()
 220         lib.Logger.Println("Terminating " + lib.MyName())
 221 }