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_debug         = flag.Bool("debug", false, "Enabling debug logging")
  35         flag_defaults_file = flag.String("defaults-file", "", "Provide a defaults-file to use to connect to MySQL")
  36         flag_help          = flag.Bool("help", false, "Provide some help for "+lib.MyName())
  37         flag_host          = flag.String("host", "", "Provide the hostname of the MySQL to connect to")
  38         flag_port          = flag.Int("port", 0 , "Provide the port number of the MySQL to connect to (default: 3306)") /* deliberately 0 here, defaults to 3306 elsewhere */
  39         flag_socket        = flag.String("socket", "", "Provide the path to the local MySQL server to connect to")
  40         flag_password      = flag.String("password", "", "Provide the password when connecting to the MySQL server")
  41         flag_user          = flag.String("user", "", "Provide the username to connect with to MySQL (default: $USER)")
  42         flag_version       = flag.Bool("version", false, "Show the version of "+lib.MyName())
  43         cpuprofile         = flag.String("cpuprofile", "", "write cpu profile to file")
  44
  45         re_valid_version = regexp.MustCompile(`^(5\.[67]\.|10\.[01])`)
  46 )
  47
  48 // Connect to the database with the given defaults-file, or ~/.my.cnf if not provided.
  49 func connect_by_defaults_file( defaults_file string ) *sql.DB {
  50         var err error
  51         var dbh *sql.DB
  52         lib.Logger.Println("connect_by_defaults_file() connecting to database")
  53
  54         dbh, err = mysql_defaults_file.OpenUsingDefaultsFile(sql_driver, defaults_file, "performance_schema")
  55         if err != nil {
  56                 log.Fatal(err)
  57         }
  58         if err = dbh.Ping(); err != nil {
  59                 log.Fatal(err)
  60         }
  61
  62         return dbh
  63 }
  64
  65 // connect to MySQL using various component parts needed to make the dsn
  66 func connect_by_components( components map[string]string ) *sql.DB {
  67         var err error
  68         var dbh *sql.DB
  69         lib.Logger.Println("connect_by_components() connecting to database")
  70
  71         new_dsn := mysql_defaults_file.BuildDSN(components, "performance_schema")
  72         dbh, err = sql.Open(sql_driver, new_dsn)
  73         if err != nil {
  74                 log.Fatal(err)
  75         }
  76         if err = dbh.Ping(); err != nil {
  77                 log.Fatal(err)
  78         }
  79
  80         return dbh
  81 }
  82
  83 // make chan for termbox events and run a poller to send events to the channel
  84 // - return the channel
  85 func new_tb_chan() chan termbox.Event {
  86         termboxChan := make(chan termbox.Event)
  87         go func() {
  88                 for {
  89                         termboxChan <- termbox.PollEvent()
  90                 }
  91         }()
  92         return termboxChan
  93 }
  94
  95 func usage() {
  96         fmt.Println(lib.MyName() + " - " + lib.Copyright())
  97         fmt.Println("")
  98         fmt.Println("Top-like program to show MySQL activity by using information collected")
  99         fmt.Println("from performance_schema.")
 100         fmt.Println("")
 101         fmt.Println("Usage: " + lib.MyName() + " <options>")
 102         fmt.Println("")
 103         fmt.Println("Options:")
 104         fmt.Println("--defaults-file=/path/to/defaults.file   Connect to MySQL using given defaults-file" )
 105         fmt.Println("--help                                   Show this help message")
 106         fmt.Println("--version                                Show the version")
 107         fmt.Println("--host=<hostname>                        MySQL host to connect to")
 108         fmt.Println("--port=<port>                            MySQL port to connect to")
 109         fmt.Println("--socket=<path>                          MySQL path of the socket to connect to")
 110         fmt.Println("--user=<user>                            User to connect with")
 111         fmt.Println("--password=<password>                    Password to use when connecting")
 112 }
 113
 114 // pstop requires MySQL 5.6+ or MariaDB 10.0+. Check the version
 115 // rather than giving an error message if the requires P_S tables can't
 116 // be found.
 117 func validate_mysql_version(dbh *sql.DB) error {
 118         var tables = [...]string{
 119                 "performance_schema.file_summary_by_instance",
 120                 "performance_schema.table_io_waits_summary_by_table",
 121                 "performance_schema.table_lock_waits_summary_by_table",
 122         }
 123
 124         lib.Logger.Println("validate_mysql_version()")
 125
 126         lib.Logger.Println("- Getting MySQL version")
 127         err, mysql_version := lib.SelectGlobalVariableByVariableName(dbh, "VERSION")
 128         if err != nil {
 129                 return err
 130         }
 131         lib.Logger.Println("- mysql_version: '" + mysql_version + "'")
 132
 133         if !re_valid_version.MatchString(mysql_version) {
 134                 err := errors.New(lib.MyName() + " does not work with MySQL version " + mysql_version)
 135                 return err
 136         }
 137         lib.Logger.Println("OK: MySQL version is valid, continuing")
 138
 139         lib.Logger.Println("Checking access to required tables:")
 140         for i := range tables {
 141                 if err := lib.CheckTableAccess(dbh, tables[i]); err == nil {
 142                         lib.Logger.Println("OK: " + tables[i] + " found")
 143                 } else {
 144                         return err
 145                 }
 146         }
 147         lib.Logger.Println("OK: all table checks passed")
 148
 149         return nil
 150 }
 151
 152 func main() {
 153         var defaults_file string = ""
 154         flag.Parse()
 155
 156         // clean me up
 157         if *cpuprofile != "" {
 158                 f, err := os.Create(*cpuprofile)
 159                 if err != nil {
 160                         log.Fatal(err)
 161                 }
 162                 pprof.StartCPUProfile(f)
 163                 defer pprof.StopCPUProfile()
 164         }
 165
 166         if *flag_debug {
 167                 lib.Logger.EnableLogging(true)
 168         }
 169         if *flag_version {
 170                 fmt.Println(lib.MyName() + " version " + version.Version())
 171                 return
 172         }
 173         if *flag_help {
 174                 usage()
 175                 return
 176         }
 177
 178         lib.Logger.Println("Starting " + lib.MyName())
 179
 180         var dbh *sql.DB
 181
 182         if *flag_host != "" || *flag_socket != "" {
 183                 lib.Logger.Println("--host= or --socket= defined")
 184                 var components = make(map[string]string)
 185                 if *flag_host != "" && *flag_socket != "" {
 186                         fmt.Println(lib.MyName() + ": Do not specify --host and --socket together" )
 187                         os.Exit(1)
 188                 }
 189                 if *flag_host != "" {
 190                         components["host"] = *flag_host
 191                 }
 192                 if *flag_port != 0 {
 193                         if *flag_socket == "" {
 194                                 components["port"] = fmt.Sprintf("%d", *flag_port)
 195                         } else {
 196                                 fmt.Println(lib.MyName() + ": Do not specify --socket and --port together" )
 197                                 os.Exit(1)
 198                         }
 199                 }
 200                 if *flag_socket != "" {
 201                         components["socket"] = *flag_socket
 202                 }
 203                 if *flag_user != "" {
 204                         components["user"] = *flag_user
 205                 }
 206                 if *flag_password != "" {
 207                         components["password"] = *flag_password
 208                 }
 209                 dbh = connect_by_components( components )
 210         } else {
 211                  if flag_defaults_file != nil && *flag_defaults_file != "" {
 212                         lib.Logger.Println("--defaults-file defined")
 213                         defaults_file = *flag_defaults_file
 214                 } else {
 215                         lib.Logger.Println("connecting by implicit defaults file")
 216                 }
 217                 dbh = connect_by_defaults_file( defaults_file )
 218         }
 219
 220         if err := validate_mysql_version(dbh); err != nil {
 221                 log.Fatal(err)
 222         }
 223
 224         var state state.State
 225         var wi wait_info.WaitInfo
 226         wi.SetWaitInterval(time.Second)
 227
 228         sigChan := make(chan os.Signal, 1)
 229         done := make(chan struct{})
 230         defer close(done)
 231         termboxChan := new_tb_chan()
 232
 233         signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
 234
 235         state.Setup(dbh)
 236         for !state.Finished() {
 237                 select {
 238                 case <-done:
 239                         fmt.Println("exiting")
 240                         state.SetFinished()
 241                 case sig := <-sigChan:
 242                         fmt.Println("Caught a signal", sig)
 243                         done <- struct{}{}
 244                 case <-wi.WaitNextPeriod():
 245                         state.Collect()
 246                         wi.CollectedNow()
 247                         state.Display()
 248                 case event := <-termboxChan:
 249                         // switch on event type
 250                         switch event.Type {
 251                         case termbox.EventKey: // actions depend on key
 252                                 switch event.Key {
 253                                 case termbox.KeyCtrlZ, termbox.KeyCtrlC, termbox.KeyEsc:
 254                                         state.SetFinished()
 255                                 case termbox.KeyArrowLeft: // left arrow change to previous display mode
 256                                         state.DisplayPrevious()
 257                                         state.Display()
 258                                 case termbox.KeyTab, termbox.KeyArrowRight: // tab or right arrow - change to next display mode
 259                                         state.DisplayNext()
 260                                         state.Display()
 261                                 }
 262                                 switch event.Ch {
 263                                 case '-': // decrease the interval if > 1
 264                                         if wi.WaitInterval() > time.Second {
 265                                                 wi.SetWaitInterval(wi.WaitInterval() - time.Second)
 266                                         }
 267                                 case '+': // increase interval by creating a new ticker
 268                                         wi.SetWaitInterval(wi.WaitInterval() + time.Second)
 269                                 case 'h', '?': // help
 270                                         state.SetHelp(!state.Help())
 271                                 case 'q': // quit
 272                                         state.SetFinished()
 273                                 case 't': // toggle between absolute/relative statistics
 274                                         state.SetWantRelativeStats(!state.WantRelativeStats())
 275                                         state.Display()
 276                                 case 'z': // reset the statistics to now by taking a query of current values
 277                                         state.ResetDBStatistics()
 278                                         state.Display()
 279                                 }
 280                         case termbox.EventResize: // set sizes
 281                                 state.ScreenSetSize(event.Width, event.Height)
 282                                 state.Display()
 283                         case termbox.EventError: // quit
 284                                 log.Fatalf("Quitting because of termbox error: \n%s\n", event.Err)
 285                         }
 286                 }
 287         }
 288         state.Cleanup()
 289         lib.Logger.Println("Terminating " + lib.MyName())
 290 }