surveil/tools/docker/alignak_container/etc/alignak/templates/time_templates.cfg

##############################################################################
##############################################################################
#                                                                            
# Different Time Check Interval Services
#                                                                            
##############################################################################
##############################################################################

##############################################################################
# Purpose of time templates :
# Simply define checks behavior of services with time template to avoid
# false alerts.
# There are three time template type : short, medium, long
# - short means that it will be no retry check for service to be in hard state
# - medium let a time period in soft state for service that can have peak load
# - long let a greater time period in soft state, meant to service where
# great variation and long charge time period are usual.
##############################################################################

# Check every 5min with immediate hard state
define service{
        name                            5min_short
        use                             generic-service
        max_check_attempts              1
        normal_check_interval           5
        retry_interval                  2
        register                        0
}

# Check every 5min with hard state 3min after first non-OK detection
define service{
        name                            5min_medium
        use                             generic-service
        max_check_attempts              2
        normal_check_interval           5
        retry_interval                  3
        register                        0
}

# Check every 5min with hard state after 30min
define service{
        name                            5min_long
        use                             generic-service
        max_check_attempts              6
        normal_check_interval           5
        retry_interval                  5
        register                        0
}

# Check every 10min with immediate hard state
define service{
        name                            10min_short
        use                             generic-service
        max_check_attempts              1
        normal_check_interval           10
        retry_interval                  5
        register                        0
}

# Check every 10min with hard state 10min after first non-OK detection
define service{
        name                            10min_medium
        use                             generic-service
        max_check_attempts              2
        normal_check_interval           10
        retry_interval                  10
        register                        0
}

# Check every 10min with hard state after 1hour
define service{
        name                            10min_long
        use                             generic-service
        max_check_attempts              6
        normal_check_interval           10
        retry_interval                  10
        register                        0
}

# Check every 20min with immediate hard state
define service{
        name                            20min_short
        use                             generic-service
        max_check_attempts              1
        normal_check_interval           20 
        retry_interval                  1
        register                        0
}

# Check every 20min with hard state 20min after first non-OK detection
define service{
        name                            20min_medium
        use                             generic-service
        max_check_attempts              2
        normal_check_interval           20 
        retry_interval                  20
        register                        0
}

# Check every 20min with hard state after 2hours
define service{
        name                            20min_long
        use                             generic-service
        max_check_attempts              6
        normal_check_interval           20 
        retry_interval                  20
        register                        0
}

# Check every 30min with immediate hard state
define service{
        name                            30min_short
        use                             generic-service
        max_check_attempts              1
        normal_check_interval           30
        retry_interval                  15
        register                        0
}

# Check every 30min with hard state 30min after first non-OK detection
define service{
        name                            30min_medium
        use                             generic-service
        max_check_attempts              2
        normal_check_interval           30
        retry_interval                  30
        register                        0
}

# Check every 30min with hard state after 6hours
define service{
        name                            30min_long
        use                             generic-service
        max_check_attempts              6
        normal_check_interval           30
        retry_interval                  30
        register                        0
}

# Check every 1hour with immediate hard state
define service{
        name                            1hour_short
        use                             generic-service
        max_check_attempts              1
        normal_check_interval           60
        retry_interval                  20
        register                        0

}

# Check every 1hour with hard state 1hour after first non-OK detection
define service{
        name                            1hour_medium
        use                             generic-service
        max_check_attempts              2
        normal_check_interval           60
        retry_interval                  60
        register                        0

}

# Check every 1hour with hard state after 6hours
define service{
        name                            1hour_long
        use                             generic-service
        max_check_attempts              6
        normal_check_interval           60
        retry_interval                  60
        register                        0

}

# Check every 12hours with immediate hard state
define service{
        name                            12hours_short
        use                             generic-service
        max_check_attempts              1
        normal_check_interval           720
        retry_interval                  360
        register                        0
}

# Check every 12hours with hard state 12hours after first non-OK detection
define service{
        name                            12hours_medium
        use                             generic-service
        max_check_attempts              2
        normal_check_interval           720
        retry_interval                  720
        register                        0
}

# Check every 12hours with hard state after 3days
define service{
        name                            12hours_long
        use                             generic-service
        max_check_attempts              6
        normal_check_interval           720
        retry_interval                  720
        register                        0
}

# Check every weeks with immediate hard state
define service{
        name                            1week_short
        use                             generic-service
        max_check_attempts              1
        normal_check_interval           10080
        retry_interval                  10
        register                        0
}

# Check every weeks with hard state 1 week after first non-OK detection
define service{
        name                            1week_medium
        use                             generic-service
        max_check_attempts              2
        normal_check_interval           10080
        retry_interval                  10080
        register                        0
}

# Check every weeks with hard state after 4 weeks
define service{
        name                            1week_long
        use                             generic-service
        max_check_attempts              6
        normal_check_interval           10080
        retry_interval                  10080
        register                        0
}