]> granicus.if.org Git - icinga2/blobdiff - lib/icinga/host.cpp
Remove the HostUnreachable state.
[icinga2] / lib / icinga / host.cpp
index dd0e7f1b6afc659db5141b243d159b85e3d1c3be..3723055bd7a4aeff21fb9f37cbf942fb377a5327 100644 (file)
@@ -134,11 +134,8 @@ Service::Ptr Host::GetServiceByShortName(const Value& name)
        }
 }
 
-HostState Host::CalculateState(ServiceState state, bool reachable)
+HostState Host::CalculateState(ServiceState state)
 {
-       if (!reachable)
-               return HostUnreachable;
-
        switch (state) {
                case StateOK:
                case StateWarning:
@@ -152,49 +149,21 @@ HostState Host::GetState(void) const
 {
        ASSERT(!OwnsLock());
 
-       if (!IsReachable())
-               return HostUnreachable;
-
-       switch (GetStateRaw()) {
-               case StateOK:
-               case StateWarning:
-                       return HostUp;
-               default:
-                       return HostDown;
-       }
-
+       return CalculateState(GetStateRaw());
 }
 
 HostState Host::GetLastState(void) const
 {
        ASSERT(!OwnsLock());
 
-       if (!IsReachable())
-               return HostUnreachable;
-
-       switch (GetLastStateRaw()) {
-               case StateOK:
-               case StateWarning:
-                       return HostUp;
-               default:
-                       return HostDown;
-       }
+       return CalculateState(GetLastStateRaw());
 }
 
 HostState Host::GetLastHardState(void) const
 {
        ASSERT(!OwnsLock());
 
-       if (!IsReachable())
-               return HostUnreachable;
-
-       switch (GetLastHardStateRaw()) {
-               case StateOK:
-               case StateWarning:
-                       return HostUp;
-               default:
-                       return HostDown;
-       }
+       return CalculateState(GetLastHardStateRaw());
 }
 
 double Host::GetLastStateUp(void) const
@@ -218,12 +187,8 @@ HostState Host::StateFromString(const String& state)
 {
        if (state == "UP")
                return HostUp;
-       else if (state == "DOWN")
-               return HostDown;
-       else if (state == "UNREACHABLE")
-               return HostUnreachable;
        else
-               return HostUnreachable;
+               return HostDown;
 }
 
 String Host::StateToString(HostState state)
@@ -233,8 +198,6 @@ String Host::StateToString(HostState state)
                        return "UP";
                case HostDown:
                        return "DOWN";
-               case HostUnreachable:
-                       return "UNREACHABLE";
                default:
                        return "INVALID";
        }
@@ -258,113 +221,156 @@ String Host::StateTypeToString(StateType type)
 
 bool Host::ResolveMacro(const String& macro, const CheckResult::Ptr&, String *result) const
 {
-       if (macro == "HOSTNAME") {
-               *result = GetName();
-               return true;
-       }
-       else if (macro == "HOSTDISPLAYNAME" || macro == "HOSTALIAS") {
-               *result = GetDisplayName();
-               return true;
-       }
+       String key;
+       Dictionary::Ptr vars;
 
-       CheckResult::Ptr cr = GetLastCheckResult();
-
-       if (macro == "HOSTSTATE") {
-               switch (GetState()) {
-                       case HostUnreachable:
-                               *result = "UNREACHABLE";
-                               break;
-                       case HostUp:
-                               *result = "UP";
-                               break;
-                       case HostDown:
-                               *result = "DOWN";
-                               break;
-                       default:
-                               ASSERT(0);
-               }
-
-               return true;
-       } else if (macro == "HOSTSTATEID") {
-               *result = Convert::ToString(GetState());
-               return true;
-       } else if (macro == "HOSTSTATETYPE") {
-               *result = StateTypeToString(GetStateType());
-               return true;
-       } else if (macro == "HOSTATTEMPT") {
-               *result = Convert::ToString(GetCheckAttempt());
-               return true;
-       } else if (macro == "MAXHOSTATTEMPT") {
-               *result = Convert::ToString(GetMaxCheckAttempts());
-               return true;
-       } else if (macro == "LASTHOSTSTATE") {
-               *result = StateToString(GetLastState());
-               return true;
-       } else if (macro == "LASTHOSTSTATEID") {
-               *result = Convert::ToString(GetLastState());
-               return true;
-       } else if (macro == "LASTHOSTSTATETYPE") {
-               *result = StateTypeToString(GetLastStateType());
-               return true;
-       } else if (macro == "LASTHOSTSTATECHANGE") {
-               *result = Convert::ToString((long)GetLastStateChange());
-               return true;
-       } else if (macro == "HOSTDURATIONSEC") {
-               *result = Convert::ToString((long)(Utility::GetTime() - GetLastStateChange()));
-               return true;
-       } else if (macro == "HOSTCHECKCOMMAND") {
-               CheckCommand::Ptr commandObj = GetCheckCommand();
-
-               if (commandObj)
-                       *result = commandObj->GetName();
-               else
-                       *result = "";
-
-               return true;
-       }
+       /* special treatment for address macros providing name fallback */
+       if (macro == "address" || macro == "address6") {
+               vars = GetVars();
 
+               String value;
+               if (vars && vars->Contains(macro))
+                       value = vars->Get(macro);
 
-       if (cr) {
-               if (macro == "HOSTLATENCY") {
-                       *result = Convert::ToString(Service::CalculateLatency(cr));
+               if (value.IsEmpty()) {
+                       *result = GetName();
                        return true;
-               } else if (macro == "HOSTEXECUTIONTIME") {
-                       *result = Convert::ToString(Service::CalculateExecutionTime(cr));
+               } else {
+                       *result = value;
                        return true;
-               } else if (macro == "HOSTOUTPUT") {
-                       *result = cr->GetOutput();
-                       return true;
-               } else if (macro == "HOSTPERFDATA") {
-                       *result = PluginUtility::FormatPerfdata(cr->GetPerformanceData());
+               }
+       }
+       else if (macro == "host.vars.address" || macro == "host.vars.address6") {
+               key = macro.SubStr(10);
+               vars = GetVars();
+
+               String value;
+               if (vars && vars->Contains(key))
+                       value = vars->Get(key);
+
+               if (value.IsEmpty()) {
+                       *result = GetName();
                        return true;
-               } else if (macro == "LASTHOSTCHECK") {
-                       *result = Convert::ToString((long)cr->GetScheduleStart());
+               } else {
+                       *result = value;
                        return true;
                }
        }
 
-       Dictionary::Ptr vars = GetVars();
+       /* require prefix for object macros */
+       if (macro.SubStr(0, 5) == "host.") {
+               key = macro.SubStr(5);
 
-       if (macro.SubStr(0, 5) == "_HOST") {
-               *result = vars ? vars->Get(macro.SubStr(5)) : "";
-               return true;
-       }
+               if (key.SubStr(0, 5) == "vars.") {
+                       vars = GetVars();
+                       String vars_key = key.SubStr(5);
 
-       String name = macro;
+                       if (vars && vars->Contains(vars_key)) {
+                               *result = vars->Get(vars_key);
+                               return true;
+                       }
+               }
+               else if (key == "name") {
+                       *result = GetName();
+                       return true;
+               }
+               else if (key == "displaymane") {
+                       *result = GetDisplayName();
+                       return true;
+               }
 
-       if (name == "HOSTADDRESS")
-               name = "address";
-       else if (macro == "HOSTADDRESS6")
-               name = "address6";
+               CheckResult::Ptr cr = GetLastCheckResult();
 
-       if (vars && vars->Contains(name)) {
-               *result = vars->Get(name);
-               return true;
-       }
+               if (key == "state") {
+                       *result = StateToString(GetState());
+                       return true;
+               } else if (key == "stateid") {
+                       *result = Convert::ToString(GetState());
+                       return true;
+               } else if (key == "statetype") {
+                       *result = StateTypeToString(GetStateType());
+                       return true;
+               } else if (key == "attempt") {
+                       *result = Convert::ToString(GetCheckAttempt());
+                       return true;
+               } else if (key == "maxattempt") {
+                       *result = Convert::ToString(GetMaxCheckAttempts());
+                       return true;
+               } else if (key == "laststate") {
+                       *result = StateToString(GetLastState());
+                       return true;
+               } else if (key == "laststateid") {
+                       *result = Convert::ToString(GetLastState());
+                       return true;
+               } else if (key == "laststatetype") {
+                       *result = StateTypeToString(GetLastStateType());
+                       return true;
+               } else if (key == "laststatechange") {
+                       *result = Convert::ToString((long)GetLastStateChange());
+                       return true;
+               } else if (key == "durationsec") {
+                       *result = Convert::ToString((long)(Utility::GetTime() - GetLastStateChange()));
+                       return true;
+               } else if (key == "checkcommand") {
+                       CheckCommand::Ptr commandObj = GetCheckCommand();
 
-       if (macro == "HOSTADDRESS" || macro == "HOSTADDRESS6") {
-               *result = GetName();
-               return true;
+                       if (commandObj)
+                               *result = commandObj->GetName();
+                       else
+                               *result = "";
+
+                       return true;
+               } else if (key == "totalservices" || key == "totalservicesok" || key == "totalserviceswarning"
+                           || key == "totalservicesunknown" || key == "totalservicescritical") {
+                               int filter = -1;
+                               int count = 0;
+
+                               if (key == "totalservicesok")
+                                       filter = StateOK;
+                               else if (key == "totalserviceswarning")
+                                       filter = StateWarning;
+                               else if (key == "totalservicesunknown")
+                                       filter = StateUnknown;
+                               else if (key == "totalservicescritical")
+                                       filter = StateCritical;
+
+                               BOOST_FOREACH(const Service::Ptr& service, GetServices()) {
+                                       if (filter != -1 && service->GetState() != filter)
+                                               continue;
+
+                                       count++;
+                               }
+
+                               *result = Convert::ToString(count);
+                               return true;
+                       }
+
+
+               if (cr) {
+                       if (key == "latency") {
+                               *result = Convert::ToString(Service::CalculateLatency(cr));
+                               return true;
+                       } else if (key == "executiontime") {
+                               *result = Convert::ToString(Service::CalculateExecutionTime(cr));
+                               return true;
+                       } else if (key == "output") {
+                               *result = cr->GetOutput();
+                               return true;
+                       } else if (key == "perfdata") {
+                               *result = PluginUtility::FormatPerfdata(cr->GetPerformanceData());
+                               return true;
+                       } else if (key == "lastcheck") {
+                               *result = Convert::ToString((long)cr->GetScheduleStart());
+                               return true;
+                       }
+               }
+       } else {
+               vars = GetVars();
+
+               if (vars && vars->Contains(macro)) {
+                       *result = vars->Get(macro);
+                       return true;
+               }
        }
 
        return false;