p_s/setup_instruments/setup_instruments.go

   1 // manage the configuration of setup_instruments
   2 package setup_instruments
   3
   4 import (
   5         "database/sql"
   6         "log"
   7
   8         "github.com/sjmudd/pstop/lib"
   9 )
  10
  11 // We only match on the error number
  12 // Error 1142: UPDATE command denied to user 'cacti'@'10.164.132.182' for table 'setup_instruments'
  13 // Error 1290: The MySQL server is running with the --read-only option so it cannot execute this statement
  14 var EXPECTED_UPDATE_ERRORS = []string{
  15         "Error 1142",
  16         "Error 1290",
  17 }
  18
  19 // one row of performance_schema.setup_instruments
  20 type table_row struct {
  21         NAME    string
  22         ENABLED string
  23         TIMED   string
  24 }
  25
  26 type table_rows []table_row
  27
  28 // SetupInstruments "object"
  29 type SetupInstruments struct {
  30         update_succeeded bool
  31         rows             table_rows
  32 }
  33
  34 // Change settings to monitor stage/sql/%
  35 func (si *SetupInstruments) EnableStageMonitoring(dbh *sql.DB) {
  36         lib.Logger.Println("EnableStageMonitoring")
  37         sql := "SELECT NAME, ENABLED, TIMED FROM setup_instruments WHERE NAME LIKE 'stage/sql/%' AND ( enabled <> 'YES' OR timed <> 'YES' )"
  38         collecting := "Collecting setup_instruments stage/sql configuration settings"
  39         updating := "Updating setup_instruments configuration for: stage/sql"
  40
  41         si.ConfigureSetupInstruments(dbh, sql, collecting, updating)
  42 }
  43
  44 // Change settings to monitor wait/synch/mutex/%
  45 func (si *SetupInstruments) EnableMutexMonitoring(dbh *sql.DB) {
  46         lib.Logger.Println("EnableMutexMonitoring")
  47         sql := "SELECT NAME, ENABLED, TIMED FROM setup_instruments WHERE NAME LIKE 'wait/synch/mutex/%' AND ( enabled <> 'YES' OR timed <> 'YES' )"
  48         collecting := "Collecting setup_instruments wait/synch/mutex configuration settings"
  49         updating := "Updating setup_instruments configuration for: wait/synch/mutex"
  50
  51         si.ConfigureSetupInstruments(dbh, sql, collecting, updating)
  52 }
  53
  54 // generic routine (now) to update some rows in setup instruments
  55 func (si *SetupInstruments) ConfigureSetupInstruments(dbh *sql.DB, select_sql string, collecting, updating string) {
  56         // setup the old values in case they're not set
  57         if si.rows == nil {
  58                 si.rows = make([]table_row, 0, 500)
  59         }
  60
  61         lib.Logger.Println(collecting)
  62
  63         rows, err := dbh.Query(select_sql)
  64         if err != nil {
  65                 log.Fatal(err)
  66         }
  67         defer rows.Close()
  68
  69         count := 0
  70         for rows.Next() {
  71                 var r table_row
  72                 if err := rows.Scan(
  73                         &r.NAME,
  74                         &r.ENABLED,
  75                         &r.TIMED); err != nil {
  76                         log.Fatal(err)
  77                 }
  78                 // we collect all information even if it's mainly empty as we may reference it later
  79                 si.rows = append(si.rows, r)
  80                 count++
  81         }
  82         if err := rows.Err(); err != nil {
  83                 log.Fatal(err)
  84         }
  85         lib.Logger.Println("- found", count, "rows whose configuration need changing")
  86
  87         // update the rows which need to be set - do multiple updates but I don't care
  88         lib.Logger.Println(updating)
  89
  90         lib.Logger.Println("- about to try to update", len(si.rows), "row(s)" )
  91         count = 0
  92         for i := range si.rows {
  93                 lib.Logger.Println("- changing row:", si.rows[i].NAME )
  94                 sql := "UPDATE setup_instruments SET enabled = 'YES', TIMED = 'YES' WHERE NAME = '" + si.rows[i].NAME + "'"
  95                 lib.Logger.Println("exec statement:", sql )
  96                 if res, err := dbh.Exec(sql); err == nil {
  97                         si.update_succeeded = true
  98                         c, _ := res.RowsAffected()
  99                         count += int(c)
 100                 } else {
 101                         found_expected := false
 102                         for i := range EXPECTED_UPDATE_ERRORS {
 103                                 if err.Error()[0:10] == EXPECTED_UPDATE_ERRORS[i] {
 104                                         found_expected = true
 105                                         break
 106                                 }
 107                         }
 108                         if !found_expected {
 109                                 log.Fatal(err)
 110                         }
 111                         lib.Logger.Println("Insufficient privileges to UPDATE setup_instruments: " + err.Error())
 112                         lib.Logger.Println("Not attempting further updates")
 113                         break
 114                 }
 115         }
 116         if si.update_succeeded {
 117                 lib.Logger.Println(count, "rows changed in p_s.setup_instruments")
 118         }
 119 }
 120
 121 // restore setup_instruments rows to their previous settings
 122 func (si *SetupInstruments) RestoreConfiguration(dbh *sql.DB) {
 123         // If the previous update didn't work then don't try to restore
 124         if !si.update_succeeded {
 125                 lib.Logger.Println("Not restoring p_s.setup_instruments to its original settings as previous UPDATE had failed")
 126                 return
 127         } else {
 128                 lib.Logger.Println("Restoring p_s.setup_instruments to its original settings")
 129         }
 130
 131         // update the rows which need to be set - do multiple updates but I don't care
 132         update_sql := "UPDATE setup_instruments SET enabled = ?, TIMED = ? WHERE NAME = ?"
 133         stmt, err := dbh.Prepare( update_sql )
 134         if err != nil {
 135                 log.Fatal(err)
 136         }
 137         count := 0
 138         for i := range si.rows {
 139                 if _, err := stmt.Exec(si.rows[i].ENABLED, si.rows[i].TIMED, si.rows[i].NAME ); err != nil {
 140                         log.Fatal(err)
 141                 }
 142                 count++
 143         }
 144         stmt.Close()
 145         lib.Logger.Println(count, "rows changed in p_s.setup_instruments")
 146 }