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         "fmt"
   7         "log"
   8
   9         "github.com/sjmudd/pstop/lib"
  10 )
  11
  12 // We only match on the error number
  13 // Error 1142: UPDATE command denied to user 'cacti'@'10.164.132.182' for table 'setup_instruments'
  14 // Error 1290: The MySQL server is running with the --read-only option so it cannot execute this statement
  15 var EXPECTED_UPDATE_ERRORS = []string{
  16         "Error 1142:",
  17         "Error 1290:",
  18 }
  19
  20 // one row of performance_schema.setup_instruments
  21 type table_row struct {
  22         NAME    string
  23         ENABLED string
  24         TIMED   string
  25 }
  26
  27 type table_rows []table_row
  28
  29 // SetupInstruments "object"
  30 type SetupInstruments struct {
  31         update_tried     bool
  32         update_succeeded bool
  33         rows             table_rows
  34         dbh              *sql.DB
  35 }
  36
  37 // Return a newly initialised SetupInstruments structure with a handle to the database.
  38 // Better to return a pointer ?
  39 func NewSetupInstruments(dbh *sql.DB) SetupInstruments {
  40         return SetupInstruments{dbh: dbh}
  41 }
  42
  43 // enable mutex and stage monitoring
  44 func (si *SetupInstruments) EnableMonitoring() {
  45         si.EnableMutexMonitoring()
  46         si.EnableStageMonitoring()
  47 }
  48
  49 // Change settings to monitor stage/sql/%
  50 func (si *SetupInstruments) EnableStageMonitoring() {
  51         lib.Logger.Println("EnableStageMonitoring")
  52         sql := "SELECT NAME, ENABLED, TIMED FROM setup_instruments WHERE NAME LIKE 'stage/sql/%' AND ( enabled <> 'YES' OR timed <> 'YES' )"
  53         collecting := "Collecting setup_instruments stage/sql configuration settings"
  54         updating := "Updating setup_instruments configuration for: stage/sql"
  55
  56         si.Configure(sql, collecting, updating)
  57         lib.Logger.Println("EnableStageMonitoring finishes")
  58 }
  59
  60 // Change settings to monitor wait/synch/mutex/%
  61 func (si *SetupInstruments) EnableMutexMonitoring() {
  62         lib.Logger.Println("EnableMutexMonitoring")
  63         sql := "SELECT NAME, ENABLED, TIMED FROM setup_instruments WHERE NAME LIKE 'wait/synch/mutex/%' AND ( enabled <> 'YES' OR timed <> 'YES' )"
  64         collecting := "Collecting setup_instruments wait/synch/mutex configuration settings"
  65         updating := "Updating setup_instruments configuration for: wait/synch/mutex"
  66
  67         si.Configure(sql, collecting, updating)
  68         lib.Logger.Println("EnableMutexMonitoring finishes")
  69 }
  70
  71 // return true if the error is not in the expected list
  72 func error_in_expected_list(actual_error string, expected_errors []string) bool {
  73         lib.Logger.Println("checking if", actual_error, "is in", expected_errors)
  74         e := actual_error[0:11]
  75         expected_error := false
  76         for i := range expected_errors {
  77                 if e == expected_errors[i] {
  78                         lib.Logger.Println("found an expected error", expected_errors[i])
  79                         expected_error = true
  80                         break
  81                 }
  82         }
  83         lib.Logger.Println("returning", expected_error)
  84         return expected_error
  85 }
  86
  87 // generic routine (now) to update some rows in setup instruments
  88 func (si *SetupInstruments) Configure(select_sql string, collecting, updating string) {
  89         lib.Logger.Println(fmt.Sprintf("Configure(%q,%q,%q)", select_sql, collecting, updating))
  90         // skip if we've tried and failed
  91         if si.update_tried && !si.update_succeeded {
  92                 lib.Logger.Println("Configure() - Skipping further configuration")
  93                 return
  94         }
  95
  96         // setup the old values in case they're not set
  97         if si.rows == nil {
  98                 si.rows = make([]table_row, 0, 500)
  99         }
 100
 101         lib.Logger.Println(collecting)
 102
 103         lib.Logger.Println("dbh.query", select_sql)
 104         rows, err := si.dbh.Query(select_sql)
 105         if err != nil {
 106                 log.Fatal(err)
 107         }
 108
 109         count := 0
 110         for rows.Next() {
 111                 var r table_row
 112                 if err := rows.Scan(
 113                         &r.NAME,
 114                         &r.ENABLED,
 115                         &r.TIMED); err != nil {
 116                         log.Fatal(err)
 117                 }
 118                 si.rows = append(si.rows, r)
 119                 count++
 120         }
 121         if err := rows.Err(); err != nil {
 122                 log.Fatal(err)
 123         }
 124         rows.Close()
 125         lib.Logger.Println("- found", count, "rows whose configuration need changing")
 126
 127         // update the rows which need to be set - do multiple updates but I don't care
 128         lib.Logger.Println(updating)
 129
 130         const update_sql = "UPDATE setup_instruments SET enabled = ?, TIMED = ? WHERE NAME = ?"
 131         lib.Logger.Println("Preparing statement:", update_sql)
 132         si.update_tried = true
 133         lib.Logger.Println("dbh.Prepare", update_sql)
 134         stmt, err := si.dbh.Prepare(update_sql)
 135         if err != nil {
 136                 lib.Logger.Println("- prepare gave error:", err.Error())
 137                 if !error_in_expected_list(err.Error(), EXPECTED_UPDATE_ERRORS) {
 138                         log.Fatal("Not expected error so giving up")
 139                 } else {
 140                         lib.Logger.Println("- expected error so not running statement")
 141                 }
 142         } else {
 143                 lib.Logger.Println("Prepare succeeded, trying to update", len(si.rows), "row(s)")
 144                 count = 0
 145                 for i := range si.rows {
 146                         lib.Logger.Println("- changing row:", si.rows[i].NAME)
 147                         lib.Logger.Println("stmt.Exec", "YES", "YES", si.rows[i].NAME)
 148                         if res, err := stmt.Exec("YES", "YES", si.rows[i].NAME); err == nil {
 149                                 lib.Logger.Println("update succeeded")
 150                                 si.update_succeeded = true
 151                                 c, _ := res.RowsAffected()
 152                                 count += int(c)
 153                         } else {
 154                                 si.update_succeeded = false
 155                                 if error_in_expected_list(err.Error(), EXPECTED_UPDATE_ERRORS) {
 156                                         lib.Logger.Println("Insufficient privileges to UPDATE setup_instruments: " + err.Error())
 157                                         lib.Logger.Println("Not attempting further updates")
 158                                         return
 159                                 } else {
 160                                         log.Fatal(err)
 161                                 }
 162                         }
 163                 }
 164                 if si.update_succeeded {
 165                         lib.Logger.Println(count, "rows changed in p_s.setup_instruments")
 166                 }
 167                 stmt.Close()
 168         }
 169         lib.Logger.Println("Configure() returns update_tried", si.update_tried, ", update_succeeded", si.update_succeeded)
 170 }
 171
 172 // restore setup_instruments rows to their previous settings
 173 func (si *SetupInstruments) RestoreConfiguration() {
 174         lib.Logger.Println("RestoreConfiguration()")
 175         // If the previous update didn't work then don't try to restore
 176         if !si.update_succeeded {
 177                 lib.Logger.Println("Not restoring p_s.setup_instruments to original settings as initial configuration attempt failed")
 178                 return
 179         } else {
 180                 lib.Logger.Println("Restoring p_s.setup_instruments to its original settings")
 181         }
 182
 183         // update the rows which need to be set - do multiple updates but I don't care
 184         update_sql := "UPDATE setup_instruments SET enabled = ?, TIMED = ? WHERE NAME = ?"
 185         lib.Logger.Println("dbh.Prepare(", update_sql, ")")
 186         stmt, err := si.dbh.Prepare(update_sql)
 187         if err != nil {
 188                 log.Fatal(err)
 189         }
 190         count := 0
 191         for i := range si.rows {
 192                 lib.Logger.Println("stmt.Exec(", si.rows[i].ENABLED, si.rows[i].TIMED, si.rows[i].NAME, ")")
 193                 if _, err := stmt.Exec(si.rows[i].ENABLED, si.rows[i].TIMED, si.rows[i].NAME); err != nil {
 194                         log.Fatal(err)
 195                 }
 196                 count++
 197         }
 198         lib.Logger.Println("stmt.Close()")
 199         stmt.Close()
 200         lib.Logger.Println(count, "rows changed in p_s.setup_instruments")
 201 }