func checkUptime() *checkers.Checker {
opts := connectionOpts{}
psr := flags.NewParser(&opts, flags.Default)
_, err := psr.Parse()
if err != nil {
os.Exit(1)
}
db := mysql.New("tcp", "", fmt.Sprintf("%s:%s", opts.mysqlSetting.Host, opts.mysqlSetting.Port), opts.mysqlSetting.User, opts.mysqlSetting.Pass, "")
err = db.Connect()
if err != nil {
return checkers.Critical("couldn't connect DB")
}
defer db.Close()
rows, res, err := db.Query("SHOW GLOBAL STATUS LIKE 'Uptime'")
if err != nil {
return checkers.Critical("couldn't execute query")
}
idxValue := res.Map("Value")
Uptime := rows[0].Int64(idxValue)
if opts.Crit > 0 && Uptime < opts.Crit {
return checkers.Critical(fmt.Sprintf("up %s < %s", uptime2str(Uptime), uptime2str(opts.Crit)))
} else if opts.Warn > 0 && Uptime < opts.Warn {
return checkers.Warning(fmt.Sprintf("up %s < %s", uptime2str(Uptime), uptime2str(opts.Warn)))
}
return checkers.Ok(fmt.Sprintf("up %s", uptime2str(Uptime)))
}
func (opts *options) run() *checkers.Checker {
missingInstances, missingMembers, err := check(opts)
if err != nil {
return checkers.Unknown(err.Error())
}
if len(missingInstances) != 0 {
var ipAddrs []string
for _, instance := range missingInstances {
ipAddrs = append(ipAddrs, aws.StringValue(instance.PrivateIpAddress))
}
return checkers.Critical(fmt.Sprintf("%d instance(s) left from Consul cluster: %v", len(ipAddrs), ipAddrs))
}
if len(missingMembers) != 0 {
var ipAddrs []string
for _, member := range missingMembers {
ipAddrs = append(ipAddrs, fmt.Sprintf("%s(%s)", member.Node, member.Address))
}
return checkers.Warning(fmt.Sprintf("%d instance(s) not properly tagged: %v", len(ipAddrs), ipAddrs))
}
return checkers.Ok("OK")
}
func run(args []string) *checkers.Checker {
_, err := flags.ParseArgs(&opts, args)
if err != nil {
os.Exit(1)
}
stat, err := os.Stat(opts.File)
if err != nil {
if opts.IgnoreMissing {
return checkers.Ok("No such file, but ignore missing is set.")
}
return checkers.Unknown(err.Error())
}
monitor := newMonitor(opts.WarningAge, opts.WarningSize, opts.CriticalAge, opts.CriticalSize)
result := checkers.OK
mtime := stat.ModTime()
age := time.Now().Unix() - mtime.Unix()
size := stat.Size()
if monitor.CheckWarning(age, size) {
result = checkers.WARNING
}
if monitor.CheckCritical(age, size) {
result = checkers.CRITICAL
}
msg := fmt.Sprintf("%s is %d seconds old (%02d:%02d:%02d) and %d bytes.\n", opts.File, age, mtime.Hour(), mtime.Minute(), mtime.Second(), size)
return checkers.NewChecker(result, msg)
}
func checkSlave(args []string) *checkers.Checker {
opts := redisSetting{}
psr := flags.NewParser(&opts, flags.Default)
psr.Usage = "slave [OPTIONS]"
_, err := psr.ParseArgs(args)
if err != nil {
fmt.Println(err)
os.Exit(1)
}
c, info, err := connectRedisGetInfo(opts)
if err != nil {
return checkers.Unknown(err.Error())
}
defer c.Close()
if status, ok := (*info)["master_link_status"]; ok {
msg := fmt.Sprintf("master_link_status: %s", status)
switch status {
case "up":
return checkers.Ok(msg)
case "down":
return checkers.Critical(msg)
default:
return checkers.Unknown(msg)
}
} else {
// it may be a master!
return checkers.Unknown("couldn't get master_link_status")
}
}
func checkReplication(args []string) *checkers.Checker {
opts := replicationOpts{}
psr := flags.NewParser(&opts, flags.Default)
psr.Usage = "replication [OPTIONS]"
_, err := psr.ParseArgs(args)
if err != nil {
os.Exit(1)
}
db := newMySQL(opts.mysqlSetting)
err = db.Connect()
if err != nil {
return checkers.Unknown("couldn't connect DB")
}
defer db.Close()
rows, res, err := db.Query("SHOW SLAVE STATUS")
if err != nil {
return checkers.Unknown("couldn't execute query")
}
if len(rows) == 0 {
return checkers.Ok("MySQL is not slave")
}
idxIoThreadRunning := res.Map("Slave_IO_Running")
idxSQLThreadRunning := res.Map("Slave_SQL_Running")
idxSecondsBehindMaster := res.Map("Seconds_Behind_Master")
ioThreadStatus := rows[0].Str(idxIoThreadRunning)
sqlThreadStatus := rows[0].Str(idxSQLThreadRunning)
secondsBehindMaster := rows[0].Int64(idxSecondsBehindMaster)
if !(ioThreadStatus == "Yes" && sqlThreadStatus == "Yes") {
return checkers.Critical("MySQL replication has been stopped")
}
checkSt := checkers.OK
msg := fmt.Sprintf("MySQL replication behind master %d seconds", secondsBehindMaster)
if secondsBehindMaster > opts.Crit {
checkSt = checkers.CRITICAL
} else if secondsBehindMaster > opts.Warn {
checkSt = checkers.WARNING
}
return checkers.NewChecker(checkSt, msg)
}
func run(args []string) *checkers.Checker {
_, err := flags.ParseArgs(&opts, args)
if err != nil {
os.Exit(1)
}
mc := memcache.New(opts.Host + ":" + opts.Port)
mc.Timeout = time.Duration(opts.Timeout) * time.Second
err = mc.Set(&memcache.Item{Key: opts.Key, Value: []byte("Check key"), Expiration: 240})
if err != nil {
return checkers.Critical("couldn't set a key: " + err.Error())
}
item, err := mc.Get(opts.Key)
if err != nil {
return checkers.Critical("couldn't get a key: " + err.Error())
}
if string(item.Value) != "Check key" {
return checkers.Critical("not correct value")
}
return checkers.Ok("Get,Set OK")
}
func checkReachable(args []string) *checkers.Checker {
opts := redisSetting{}
psr := flags.NewParser(&opts, flags.Default)
psr.Usage = "reachable [OPTIONS]"
_, err := psr.ParseArgs(args)
if err != nil {
fmt.Println(err)
os.Exit(1)
}
c, info, err := connectRedisGetInfo(opts)
if err != nil {
return checkers.Unknown(err.Error())
}
defer c.Close()
if _, ok := (*info)["redis_version"]; !ok {
return checkers.Unknown("couldn't get redis_version")
}
return checkers.Ok(
fmt.Sprintf("version: %s", (*info)["redis_version"]),
)
}