src/WINNT/afssvrmgr/alert.cpp

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 extern "C" {
  11 #include <afs/param.h>
  12 #include <afs/stds.h>
  13 }
  14
  15 #include "svrmgr.h"
  16 #include "alert.h"
  17 #include "creds.h"
  18
  19
  20 /*
  21  * DEFINITIONS ________________________________________________________________
  22  *
  23  */
  24
  25
  26 /*
  27  * VARIABLES __________________________________________________________________
  28  *
  29  */
  30
  31
  32 /*
  33  * PROTOTYPES _________________________________________________________________
  34  *
  35  */
  36
  37 BOOL Alert_Scout_CheckServer (LPSERVER lpServer);
  38
  39 void Alert_BeginUpdate (LPIDENT lpi, LPSERVER *ppServer);
  40 void Alert_EndUpdate (LPIDENT lpi, LPSERVER lpServer);
  41
  42 void Alert_RemoveFunc (LPOBJECTALERTS lpoa, size_t iAlert);
  43 LPTSTR Alert_GetDescriptionFunc (LPIDENT lpiPrimary, size_t iAlertPrimary, LPIDENT lpiServer, BOOL fFull);
  44 LPTSTR Alert_GetRemedyFunc (LPIDENT lpiPrimary, size_t iAlertPrimary, LPIDENT lpiServer);
  45 LPTSTR Alert_GetButtonFunc (LPIDENT lpiPrimary, size_t iAlertPrimary, LPIDENT lpiServer);
  46
  47 DWORD WINAPI Alert_ScoutProc (LPVOID lp);
  48 void Alert_Scout_SetUpToDate (LPOBJECTALERTS lpoa);
  49
  50
  51 /*
  52  * ROUTINES ___________________________________________________________________
  53  *
  54  */
  55
  56 LPOBJECTALERTS Alert_GetObjectAlerts (LPIDENT lpi, BOOL fAlwaysServer, ULONG *pStatus)
  57 {
  58    LPOBJECTALERTS lpoa = NULL;
  59
  60    if (fAlwaysServer || lpi->fIsServer())
  61       {
  62       LPSERVER_PREF lpsp;
  63       if ((lpsp = (LPSERVER_PREF)lpi->GetServer()->GetUserParam()) != NULL)
  64          {
  65          lpoa = &lpsp->oa;
  66          }
  67       }
  68    else if (lpi->fIsService())
  69       {
  70       LPSERVICE_PREF lpsp;
  71       if ((lpsp = (LPSERVICE_PREF)lpi->GetUserParam()) != NULL)
  72          {
  73          lpoa = &lpsp->oa;
  74          }
  75       }
  76    else if (lpi->fIsAggregate())
  77       {
  78       LPAGGREGATE_PREF lpap;
  79       if ((lpap = (LPAGGREGATE_PREF)lpi->GetUserParam()) != NULL)
  80          {
  81          lpoa = &lpap->oa;
  82          }
  83       }
  84    else if (lpi->fIsFileset())
  85       {
  86       LPFILESET_PREF lpfp;
  87       if ((lpfp = (LPFILESET_PREF)lpi->GetUserParam()) != NULL)
  88          {
  89          lpoa = &lpfp->oa;
  90          }
  91       }
  92
  93    return lpoa;
  94 }
  95
  96
  97 void Alert_BeginUpdate (LPIDENT lpi, LPSERVER *ppServer)
  98 {
  99    if (lpi->fIsServer())
 100       {
 101       *ppServer = NULL;
 102       }
 103    else
 104       {
 105       *ppServer = lpi->OpenServer();
 106       }
 107 }
 108
 109
 110 void Alert_EndUpdate (LPIDENT lpi, LPSERVER lpServer)
 111 {
 112    // If we just updated some aggregate, fileset or service, then the
 113    // associated server's secondary alerts are probably out-of-date.
 114    // Update them.
 115    //
 116    if (lpServer != NULL)
 117       {
 118       LPOBJECTALERTS lpoaServer = Alert_GetObjectAlerts (lpServer->GetIdentifier());
 119       LPOBJECTALERTS lpoaChild  = Alert_GetObjectAlerts (lpi);
 120
 121       if (lpoaServer)
 122          {
 123          for (size_t iAlert = 0; iAlert < lpoaServer->nAlerts; )
 124             {
 125             if ( (lpoaServer->aAlerts[ iAlert ].alert == alertSECONDARY) &&
 126                  (lpoaServer->aAlerts[ iAlert ].aiSECONDARY.lpiSecondary == lpi) )
 127                {
 128                Alert_RemoveFunc (lpoaServer, iAlert);
 129                }
 130             else
 131                {
 132                ++iAlert;
 133                }
 134             }
 135          }
 136
 137       if (lpoaServer && lpoaChild)
 138          {
 139          BOOL fNeedBadCredsWarning = FALSE;
 140          BOOL fHaveBadCredsWarning = FALSE;
 141
 142          for (size_t iAlert = 0; iAlert < lpoaServer->nAlerts; ++iAlert)
 143             {
 144             if (lpoaServer->aAlerts[ iAlert ].alert == alertSECONDARY)
 145                {
 146                ALERT alert = Alert_GetAlert (lpoaServer->aAlerts[ iAlert ].aiSECONDARY.lpiSecondary,
 147                                              lpoaServer->aAlerts[ iAlert ].aiSECONDARY.iSecondary);
 148                if (alert == alertNO_SVRENT)
 149                   fNeedBadCredsWarning = TRUE;
 150                }
 151             }
 152          for (iAlert = 0; iAlert < lpoaChild->nAlerts; ++iAlert)
 153             {
 154             if (lpoaChild->aAlerts[ iAlert ].alert == alertNO_SVRENT)
 155                fNeedBadCredsWarning = TRUE;
 156             }
 157          if (lpoaServer->nAlerts &&
 158              lpoaServer->aAlerts[ 0 ].alert == alertBADCREDS)
 159             {
 160             fHaveBadCredsWarning = TRUE;
 161             }
 162
 163          if (fNeedBadCredsWarning)
 164             {
 165             fNeedBadCredsWarning = !CheckCredentials (FALSE);
 166             }
 167
 168          if (fHaveBadCredsWarning && !fNeedBadCredsWarning)
 169             {
 170             Alert_RemoveFunc (lpoaServer, 0);
 171             }
 172          else if (fNeedBadCredsWarning && !fHaveBadCredsWarning)
 173             {
 174             for (iAlert = min( lpoaServer->nAlerts, nAlertsMAX-1 );
 175                  iAlert > 0;
 176                  --iAlert)
 177                {
 178                memcpy (&lpoaServer->aAlerts[ iAlert ], &lpoaServer->aAlerts[ iAlert-1 ], sizeof(ALERTINFO));
 179                }
 180             lpoaServer->aAlerts[0].alert = alertBADCREDS;
 181             lpoaServer->nAlerts = min( nAlertsMAX, lpoaServer->nAlerts+1 );
 182             }
 183
 184          for (iAlert = 0; iAlert < lpoaChild->nAlerts; ++iAlert)
 185             {
 186             if (lpoaServer->nAlerts < nAlertsMAX)
 187                {
 188                lpoaServer->aAlerts[ lpoaServer->nAlerts ].alert = alertSECONDARY;
 189                lpoaServer->aAlerts[ lpoaServer->nAlerts ].aiSECONDARY.lpiSecondary = lpi;
 190                lpoaServer->aAlerts[ lpoaServer->nAlerts ].aiSECONDARY.iSecondary = iAlert;
 191                lpoaServer->nAlerts ++;
 192                }
 193             }
 194          }
 195
 196       lpServer->Close();
 197       }
 198 }
 199
 200
 201 void Alert_SetDefaults (LPOBJECTALERTS lpoa)
 202 {
 203    if (lpoa != NULL)
 204       {
 205       memset (lpoa, 0x00, sizeof(OBJECTALERTS));
 206       lpoa->cTickRefresh = DEFAULT_SCOUT_REFRESH_RATE;
 207       }
 208 }
 209
 210
 211 void Alert_Initialize (LPOBJECTALERTS lpoa)
 212 {
 213    if (lpoa != NULL)
 214       {
 215       lpoa->dwTickNextTest = 0;
 216       lpoa->dwTickNextRefresh = 0;
 217       lpoa->nAlerts = 0;
 218       }
 219 }
 220
 221
 222 void Alert_RemoveSecondary (LPIDENT lpiChild)
 223 {
 224    BOOL fChangedAlerts = FALSE;
 225
 226    LPOBJECTALERTS lpoa;
 227    if ((lpoa = Alert_GetObjectAlerts (lpiChild, TRUE)) != NULL)
 228       {
 229       for (size_t iAlert = 0; iAlert < lpoa->nAlerts; )
 230          {
 231          if ( (lpoa->aAlerts[ iAlert ].alert == alertSECONDARY) &&
 232               (lpoa->aAlerts[ iAlert ].aiSECONDARY.lpiSecondary == lpiChild) )
 233             {
 234             Alert_RemoveFunc (lpoa, iAlert);
 235             fChangedAlerts = TRUE;
 236             }
 237          else
 238             {
 239             ++iAlert;
 240             }
 241          }
 242
 243
 244       BOOL fNeedBadCredsWarning = FALSE;
 245
 246       for (iAlert = 0; iAlert < lpoa->nAlerts; ++iAlert)
 247          {
 248          if (lpoa->aAlerts[ iAlert ].alert == alertSECONDARY)
 249             {
 250             ALERT alert = Alert_GetAlert (lpoa->aAlerts[ iAlert ].aiSECONDARY.lpiSecondary,
 251                                           lpoa->aAlerts[ iAlert ].aiSECONDARY.iSecondary);
 252             if (alert == alertNO_SVRENT)
 253                fNeedBadCredsWarning = TRUE;
 254             }
 255          }
 256
 257       if ( (!fNeedBadCredsWarning) &&
 258            (lpoa->nAlerts && (lpoa->aAlerts[ 0 ].alert == alertBADCREDS)) )
 259          {
 260          Alert_RemoveFunc (lpoa, 0);
 261          fChangedAlerts = TRUE;
 262          }
 263       }
 264
 265    if (fChangedAlerts)
 266       {
 267       PostNotification (evtAlertsChanged, lpiChild->GetServer());
 268       PostNotification (evtAlertsChanged, lpiChild);
 269       }
 270 }
 271
 272
 273 void Alert_Remove (LPIDENT lpi, size_t iAlert)
 274 {
 275    LPOBJECTALERTS lpoa;
 276
 277    if ((lpoa = Alert_GetObjectAlerts (lpi)) != NULL)
 278       {
 279       if (iAlert < lpoa->nAlerts)
 280          {
 281          LPSERVER lpServer;
 282          Alert_BeginUpdate (lpi, &lpServer);
 283
 284          Alert_RemoveFunc (lpoa, iAlert);
 285
 286          Alert_EndUpdate (lpi, lpServer);
 287          }
 288       }
 289 }
 290
 291
 292 void Alert_RemoveFunc (LPOBJECTALERTS lpoa, size_t iAlert)
 293 {
 294    if (iAlert < lpoa->nAlerts-1)
 295       {
 296       memcpy (&lpoa->aAlerts[ iAlert ], &lpoa->aAlerts[ lpoa->nAlerts-1 ], sizeof(ALERTINFO));
 297       }
 298    lpoa->nAlerts --;
 299 }
 300
 301
 302 void Alert_AddPrimary (LPIDENT lpi, LPALERTINFO lpai)
 303 {
 304    LPOBJECTALERTS lpoa;
 305
 306    if ((lpoa = Alert_GetObjectAlerts (lpi)) != NULL)
 307       {
 308       if (lpoa->nAlerts < nAlertsMAX)
 309          {
 310          LPSERVER lpServer;
 311          Alert_BeginUpdate (lpi, &lpServer);
 312
 313          memcpy (&lpoa->aAlerts[ lpoa->nAlerts ], lpai, sizeof(ALERTINFO));
 314          lpoa->nAlerts ++;
 315
 316          Alert_EndUpdate (lpi, lpServer);
 317          }
 318       }
 319 }
 320
 321
 322 void Alert_Scout_ServerStatus (LPIDENT lpi, ULONG status)
 323 {
 324    LPOBJECTALERTS lpoa;
 325    if ((lpoa = Alert_GetObjectAlerts (lpi)) != NULL)
 326       {
 327       BOOL fChanged = FALSE;
 328
 329       for (size_t iAlert = 0; iAlert < lpoa->nAlerts; ++iAlert)
 330          {
 331          if (lpoa->aAlerts[ iAlert ].alert == alertTIMEOUT)
 332             {
 333             fChanged = TRUE;
 334             Alert_RemoveFunc (lpoa, iAlert);
 335             break;
 336             }
 337          }
 338
 339       if (status != 0)
 340          {
 341          size_t iInsert = 0;
 342          if (lpoa->nAlerts && (lpoa->aAlerts[0].alert == alertBADCREDS))
 343             iInsert = 1;
 344
 345          for (size_t iHole = iInsert; iHole < lpoa->nAlerts; ++iHole)
 346             {
 347             if (lpoa->aAlerts[ iHole ].alert == alertINVALID)
 348                break;
 349             }
 350          if (iHole < nAlertsMAX)
 351             {
 352             for (size_t iTarget = iHole; iTarget > iInsert; --iTarget)
 353                {
 354                memcpy (&lpoa->aAlerts[ iTarget ], &lpoa->aAlerts[ iTarget-1 ], sizeof(ALERTINFO));
 355                }
 356
 357             lpoa->nAlerts ++;
 358             lpoa->aAlerts[ iInsert ].alert = alertTIMEOUT;
 359             lpoa->aAlerts[ iInsert ].aiTIMEOUT.status = status;
 360             lpoa->aAlerts[ iInsert ].aiTIMEOUT.stLastAttempt;
 361             GetSystemTime (&lpoa->aAlerts[ iInsert ].aiTIMEOUT.stLastAttempt);
 362
 363             fChanged = TRUE;
 364             }
 365          }
 366
 367       if (fChanged)
 368          {
 369          PostNotification (evtAlertsChanged, lpi);
 370          }
 371       }
 372 }
 373
 374
 375 size_t Alert_GetCount (LPIDENT lpi)
 376 {
 377    LPOBJECTALERTS lpoa;
 378
 379    if ((lpoa = Alert_GetObjectAlerts (lpi)) == NULL)
 380       return 0;
 381
 382    return lpoa->nAlerts;
 383 }
 384
 385
 386 ALERT Alert_GetAlert (LPIDENT lpi, size_t iAlert)
 387 {
 388    LPOBJECTALERTS lpoa;
 389
 390    if ((lpoa = Alert_GetObjectAlerts (lpi)) == NULL)
 391       return alertINVALID;
 392
 393    if (iAlert > lpoa->nAlerts)
 394       return alertINVALID;
 395
 396    if (lpoa->aAlerts[ iAlert ].alert == alertSECONDARY)
 397       {
 398       return Alert_GetAlert (lpoa->aAlerts[ iAlert ].aiSECONDARY.lpiSecondary,
 399                              lpoa->aAlerts[ iAlert ].aiSECONDARY.iSecondary);
 400       }
 401
 402    return lpoa->aAlerts[ iAlert ].alert;
 403 }
 404
 405
 406 LPIDENT Alert_GetIdent (LPIDENT lpi, size_t iAlert)
 407 {
 408    LPOBJECTALERTS lpoa;
 409
 410    if ((lpoa = Alert_GetObjectAlerts (lpi)) == NULL)
 411       return NULL;
 412
 413    if (iAlert > lpoa->nAlerts)
 414       return NULL;
 415
 416    if (lpoa->aAlerts[ iAlert ].alert == alertSECONDARY)
 417       {
 418       return lpoa->aAlerts[ iAlert ].aiSECONDARY.lpiSecondary;
 419       }
 420
 421    return lpi;
 422 }
 423
 424
 425 LPTSTR Alert_GetQuickDescription (LPIDENT lpi)
 426 {
 427    LPTSTR pszStatus = NULL;
 428
 429    size_t cAlerts;
 430    if ((cAlerts = Alert_GetCount (lpi)) <= 1)
 431       pszStatus = Alert_GetDescription (lpi, 0, FALSE);
 432    else if (lpi->fIsServer())
 433       pszStatus = FormatString (IDS_SERVER_MULTIPLE_PROBLEMS, TEXT("%lu"), cAlerts);
 434    else if (lpi->fIsService())
 435       pszStatus = FormatString (IDS_SERVICE_MULTIPLE_PROBLEMS, TEXT("%lu"), cAlerts);
 436    else if (lpi->fIsAggregate())
 437       pszStatus = FormatString (IDS_AGGREGATE_MULTIPLE_PROBLEMS, TEXT("%lu"), cAlerts);
 438    else if (lpi->fIsFileset())
 439       pszStatus = FormatString (IDS_FILESET_MULTIPLE_PROBLEMS, TEXT("%lu"), cAlerts);
 440
 441    return pszStatus;
 442 }
 443
 444
 445 LPTSTR Alert_GetDescription (LPIDENT lpi, size_t iAlert, BOOL fFull)
 446 {
 447    LPOBJECTALERTS lpoa;
 448
 449    if ((lpoa = Alert_GetObjectAlerts (lpi)) == NULL)
 450       return NULL;
 451
 452    if (!lpoa->nAlerts && lpi->fIsServer())
 453       {
 454       LPSERVER_PREF lpsp;
 455       if ((lpsp = (LPSERVER_PREF)lpi->GetUserParam()) != NULL)
 456          {
 457          if (!lpsp->fIsMonitored)
 458             {
 459             TCHAR szName[ cchNAME ];
 460             lpi->GetServerName (szName);
 461             return FormatString (IDS_ALERT_DESCSHORT_UNMONITORED, TEXT("%s"), szName);
 462             }
 463          }
 464       }
 465
 466    if (iAlert >= lpoa->nAlerts)
 467       return NULL;
 468
 469    if (lpoa->aAlerts[ iAlert ].alert == alertSECONDARY)
 470       {
 471       return Alert_GetDescriptionFunc (lpoa->aAlerts[ iAlert ].aiSECONDARY.lpiSecondary,
 472                                        lpoa->aAlerts[ iAlert ].aiSECONDARY.iSecondary,
 473                                        lpi,
 474                                        fFull);
 475       }
 476
 477    return Alert_GetDescriptionFunc (lpi, iAlert, NULL, fFull);
 478 }
 479
 480
 481 LPTSTR Alert_GetRemedy (LPIDENT lpi, size_t iAlert)
 482 {
 483    LPOBJECTALERTS lpoa;
 484
 485    if ((lpoa = Alert_GetObjectAlerts (lpi)) == NULL)
 486       return NULL;
 487
 488    if (iAlert >= lpoa->nAlerts)
 489       return NULL;
 490
 491    if (lpoa->aAlerts[ iAlert ].alert == alertSECONDARY)
 492       {
 493       return Alert_GetRemedyFunc (lpoa->aAlerts[ iAlert ].aiSECONDARY.lpiSecondary,
 494                                   lpoa->aAlerts[ iAlert ].aiSECONDARY.iSecondary,
 495                                   lpi);
 496       }
 497
 498    return Alert_GetRemedyFunc (lpi, iAlert, NULL);
 499 }
 500
 501
 502 LPTSTR Alert_GetButton (LPIDENT lpi, size_t iAlert)
 503 {
 504    LPOBJECTALERTS lpoa;
 505
 506    if ((lpoa = Alert_GetObjectAlerts (lpi)) == NULL)
 507       return NULL;
 508
 509    if (iAlert >= lpoa->nAlerts)
 510       return NULL;
 511
 512    if (lpoa->aAlerts[ iAlert ].alert == alertSECONDARY)
 513       {
 514       return Alert_GetButtonFunc (lpoa->aAlerts[ iAlert ].aiSECONDARY.lpiSecondary,
 515                                   lpoa->aAlerts[ iAlert ].aiSECONDARY.iSecondary,
 516                                   lpi);
 517       }
 518
 519    return Alert_GetButtonFunc (lpi, iAlert, NULL);
 520 }
 521
 522
 523 LPTSTR Alert_GetDescriptionFunc (LPIDENT lpiPrimary, size_t iAlertPrimary, LPIDENT lpiServer, BOOL fFull)
 524 {
 525    LPOBJECTALERTS lpoa;
 526    if ((lpoa = Alert_GetObjectAlerts (lpiPrimary)) != NULL)
 527       {
 528       int ids;
 529       TCHAR szServer[ cchRESOURCE ];
 530       TCHAR szService[ cchRESOURCE ];
 531       TCHAR szAggregate[ cchRESOURCE ];
 532       TCHAR szFileset[ cchRESOURCE ];
 533
 534       switch (lpoa->aAlerts[ iAlertPrimary ].alert)
 535          {
 536          case alertTIMEOUT:
 537             ids = (fFull) ? IDS_ALERT_DESCFULL_TIMEOUT : IDS_ALERT_DESCSHORT_TIMEOUT;
 538             lpiPrimary->GetServerName (szServer);
 539             return FormatString (ids, TEXT("%s%t%e"), szServer, &lpoa->aAlerts[ iAlertPrimary ].aiTIMEOUT.stLastAttempt, lpoa->aAlerts[ iAlertPrimary ].aiTIMEOUT.status);
 540
 541          case alertFULL:
 542             lpiPrimary->GetServerName (szServer);
 543             lpiPrimary->GetAggregateName (szAggregate);
 544             if (lpiPrimary->fIsAggregate())
 545                {
 546                ids = (fFull) ? IDS_ALERT_DESCFULL_AGG_FULL : IDS_ALERT_DESCSHORT_AGG_FULL;
 547                return FormatString (ids, TEXT("%s%s%d%.1B"), szServer, szAggregate, lpoa->aAlerts[ iAlertPrimary ].aiFULL.perWarning, 1024.0 * (double)lpoa->aAlerts[ iAlertPrimary ].aiFULL.ckWarning);
 548                }
 549             else if (lpiPrimary->fIsFileset())
 550                {
 551                ids = (fFull) ? IDS_ALERT_DESCFULL_SET_FULL : IDS_ALERT_DESCSHORT_SET_FULL;
 552                lpiPrimary->GetFilesetName (szFileset);
 553                return FormatString (ids, TEXT("%s%s%s%d%.1B"), szServer, szAggregate, szFileset, lpoa->aAlerts[ iAlertPrimary ].aiFULL.perWarning, 1024.0 * (double)lpoa->aAlerts[ iAlertPrimary ].aiFULL.ckWarning);
 554                }
 555             break;
 556
 557          case alertNO_VLDBENT:
 558             ids = (fFull) ? IDS_ALERT_DESCFULL_NO_VLDBENT : IDS_ALERT_DESCSHORT_NO_VLDBENT;
 559             lpiPrimary->GetServerName (szServer);
 560             lpiPrimary->GetAggregateName (szAggregate);
 561             lpiPrimary->GetFilesetName (szFileset);
 562             return FormatString (ids, TEXT("%s%s%s"), szServer, szAggregate, szFileset);
 563
 564          case alertNO_SVRENT:
 565             if (lpiPrimary->fIsFileset())
 566                {
 567                ids = (fFull) ? IDS_ALERT_DESCFULL_NO_SVRENT_SET : IDS_ALERT_DESCSHORT_NO_SVRENT_SET;
 568                lpiPrimary->GetServerName (szServer);
 569                lpiPrimary->GetAggregateName (szAggregate);
 570                lpiPrimary->GetFilesetName (szFileset);
 571                return FormatString (ids, TEXT("%s%s%s"), szServer, szAggregate, szFileset);
 572                }
 573             else
 574                {
 575                ids = (fFull) ? IDS_ALERT_DESCFULL_NO_SVRENT_AGG : IDS_ALERT_DESCSHORT_NO_SVRENT_AGG;
 576                lpiPrimary->GetServerName (szServer);
 577                lpiPrimary->GetAggregateName (szAggregate);
 578                return FormatString (ids, TEXT("%s%s"), szServer, szAggregate);
 579                }
 580             break;
 581
 582          case alertSTOPPED:
 583             ids = (fFull) ? IDS_ALERT_DESCFULL_STOPPED : IDS_ALERT_DESCSHORT_STOPPED;
 584             lpiPrimary->GetServerName (szServer);
 585             lpiPrimary->GetServiceName (szService);
 586             return FormatString (ids, TEXT("%s%s%t%t%lu"), szServer, szService, &lpoa->aAlerts[ iAlertPrimary ].aiSTOPPED.stStopped, &lpoa->aAlerts[ iAlertPrimary ].aiSTOPPED.stLastError, lpoa->aAlerts[ iAlertPrimary ].aiSTOPPED.errLastError);
 587
 588          case alertBADCREDS:
 589             ids = (fFull) ? IDS_ALERT_DESCFULL_BADCREDS : IDS_ALERT_DESCSHORT_BADCREDS;
 590             lpiPrimary->GetServerName (szServer);
 591             return FormatString (ids, TEXT("%s"), szServer);
 592
 593          case alertOVERALLOC:
 594             lpiPrimary->GetServerName (szServer);
 595             lpiPrimary->GetAggregateName (szAggregate);
 596             ids = (fFull) ? IDS_ALERT_DESCFULL_AGG_ALLOC : IDS_ALERT_DESCSHORT_AGG_ALLOC;
 597             return FormatString (ids, TEXT("%s%s%.1B%.1B"), szServer, szAggregate, 1024.0 * (double)(lpoa->aAlerts[ iAlertPrimary ].aiOVERALLOC.ckCapacity), 1024.0 * (double)(lpoa->aAlerts[ iAlertPrimary ].aiOVERALLOC.ckAllocated));
 598
 599          case alertSTATE_NO_VNODE:
 600             ids = (fFull) ? IDS_ALERT_DESCFULL_STATE_NO_VNODE : IDS_ALERT_DESCSHORT_STATE_NO_VNODE;
 601             lpiPrimary->GetServerName (szServer);
 602             lpiPrimary->GetAggregateName (szAggregate);
 603             lpiPrimary->GetFilesetName (szFileset);
 604             return FormatString (ids, TEXT("%s%s%s%08lX"), szServer, szAggregate, szFileset, lpoa->aAlerts[ iAlertPrimary ].aiSTATE.State);
 605
 606          case alertSTATE_NO_SERVICE:
 607             ids = (fFull) ? IDS_ALERT_DESCFULL_STATE_NO_SERVICE : IDS_ALERT_DESCSHORT_STATE_NO_SERVICE;
 608             lpiPrimary->GetServerName (szServer);
 609             lpiPrimary->GetAggregateName (szAggregate);
 610             lpiPrimary->GetFilesetName (szFileset);
 611             return FormatString (ids, TEXT("%s%s%s%08lX"), szServer, szAggregate, szFileset, lpoa->aAlerts[ iAlertPrimary ].aiSTATE.State);
 612
 613          case alertSTATE_OFFLINE:
 614             ids = (fFull) ? IDS_ALERT_DESCFULL_STATE_OFFLINE : IDS_ALERT_DESCSHORT_STATE_OFFLINE;
 615             lpiPrimary->GetServerName (szServer);
 616             lpiPrimary->GetAggregateName (szAggregate);
 617             lpiPrimary->GetFilesetName (szFileset);
 618             return FormatString (ids, TEXT("%s%s%s%08lX"), szServer, szAggregate, szFileset, lpoa->aAlerts[ iAlertPrimary ].aiSTATE.State);
 619          }
 620       }
 621
 622    return NULL;
 623 }
 624
 625
 626 LPTSTR Alert_GetRemedyFunc (LPIDENT lpiPrimary, size_t iAlertPrimary, LPIDENT lpiServer)
 627 {
 628    LPOBJECTALERTS lpoa;
 629    if ((lpoa = Alert_GetObjectAlerts (lpiPrimary)) != NULL)
 630       {
 631       switch (lpoa->aAlerts[ iAlertPrimary ].alert)
 632          {
 633          case alertTIMEOUT:
 634             return FormatString (IDS_ALERT_FIX_TIMEOUT);
 635          case alertFULL:
 636             if (lpiPrimary->fIsAggregate())
 637                return FormatString (IDS_ALERT_FIX_AGG_FULL);
 638             else if (lpiPrimary->fIsFileset())
 639                return FormatString (IDS_ALERT_FIX_SET_FULL);
 640             break;
 641          case alertNO_VLDBENT:
 642             return FormatString (IDS_ALERT_FIX_NO_VLDBENT);
 643          case alertNO_SVRENT:
 644             if (lpiPrimary->fIsFileset())
 645                return FormatString (IDS_ALERT_FIX_NO_SVRENT_SET);
 646             else
 647                return FormatString (IDS_ALERT_FIX_NO_SVRENT_AGG);
 648             break;
 649          case alertSTOPPED:
 650             return FormatString (IDS_ALERT_FIX_STOPPED);
 651          case alertBADCREDS:
 652             return FormatString (IDS_ALERT_FIX_BADCREDS);
 653          case alertOVERALLOC:
 654             return FormatString (IDS_ALERT_FIX_AGG_ALLOC);
 655          case alertSTATE_NO_VNODE:
 656             return FormatString (IDS_ALERT_FIX_STATE_NO_VNODE);
 657          case alertSTATE_NO_SERVICE:
 658             return FormatString (IDS_ALERT_FIX_STATE_NO_SERVICE);
 659          case alertSTATE_OFFLINE:
 660             return FormatString (IDS_ALERT_FIX_STATE_OFFLINE);
 661          }
 662       }
 663
 664    return NULL;
 665 }
 666
 667
 668 LPTSTR Alert_GetButtonFunc (LPIDENT lpiPrimary, size_t iAlertPrimary, LPIDENT lpiServer)
 669 {
 670    LPOBJECTALERTS lpoa;
 671    if ((lpoa = Alert_GetObjectAlerts (lpiPrimary)) != NULL)
 672       {
 673       switch (lpoa->aAlerts[ iAlertPrimary ].alert)
 674          {
 675          case alertTIMEOUT:
 676             return FormatString (IDS_ALERT_BUTTON_TRYAGAIN);
 677          case alertFULL:
 678             return FormatString (IDS_ALERT_BUTTON_WARNINGS);
 679          case alertNO_VLDBENT:
 680             return NULL;
 681          case alertNO_SVRENT:
 682             return NULL;
 683          case alertSTOPPED:
 684             return FormatString (IDS_ALERT_BUTTON_VIEWLOG);
 685          case alertBADCREDS:
 686             return FormatString (IDS_ALERT_BUTTON_GETCREDS);
 687          case alertOVERALLOC:
 688             return NULL;
 689          case alertSTATE_NO_VNODE:
 690             return NULL;
 691          case alertSTATE_NO_SERVICE:
 692             return NULL;
 693          case alertSTATE_OFFLINE:
 694             return NULL;
 695          }
 696       }
 697
 698    return NULL;
 699 }
 700
 701
 702 /*
 703  * SCOUT ______________________________________________________________________
 704  *
 705  * (okay, well, our simulated Scout anyway)
 706  *
 707  */
 708
 709 static HANDLE hScout = 0;       // scout's thread
 710 static HANDLE heScoutWakeup = 0;        // scout's wakeup event
 711
 712 BOOL Alert_StartScout (ULONG *pStatus)
 713 {
 714    if (hScout == 0)  // create scout?
 715       {
 716       heScoutWakeup = CreateEvent (NULL, FALSE, FALSE, NULL);
 717
 718       DWORD dwThreadID;
 719       if ((hScout = CreateThread (NULL, 0,
 720                                   (LPTHREAD_START_ROUTINE)Alert_ScoutProc,
 721                                   NULL, 0,
 722                                   &dwThreadID)) == NULL)
 723          {
 724          if (pStatus)
 725             *pStatus = GetLastError();
 726          return FALSE;
 727          }
 728
 729       SetThreadPriority (hScout, THREAD_PRIORITY_BELOW_NORMAL);
 730       }
 731    else // or just wake up scout from its slumber?
 732       {
 733       PulseEvent (heScoutWakeup);
 734       }
 735
 736    return TRUE;
 737 }
 738
 739
 740 BOOL Alert_Scout_QueueCheckServer (LPIDENT lpiServer, ULONG *pStatus)
 741 {
 742    Alert_Scout_SetOutOfDate (lpiServer);
 743    return Alert_StartScout (pStatus);
 744 }
 745
 746
 747 DWORD WINAPI Alert_ScoutProc (LPVOID lp)
 748 {
 749    // We'll keep working forever...
 750    //
 751    for (;;)
 752       {
 753       AfsClass_Enter();
 754
 755       LPCELL lpCell = (g.lpiCell == NULL) ? NULL : g.lpiCell->OpenCell();
 756       if (lpCell != NULL)
 757          {
 758          // See if our credentials have expired
 759          //
 760          CheckForExpiredCredentials();
 761
 762          // See if any new servers have arrived, or old servers disappeared.
 763          //
 764          lpCell->RefreshServerList();
 765
 766          // Check all the out-of-date servers we can find.
 767          //
 768          HENUM hEnum;
 769          for (LPSERVER lpServer = lpCell->ServerFindFirst (&hEnum); lpServer; lpServer = lpCell->ServerFindNext (&hEnum))
 770             {
 771             LPIDENT lpiServer = lpServer->GetIdentifier();
 772             LPOBJECTALERTS lpoa;
 773
 774             if ( ((lpoa = Alert_GetObjectAlerts (lpiServer)) != NULL) &&
 775                  (lpoa->dwTickNextTest <= GetTickCount()) )
 776                {
 777
 778                // Okay!  We've found a server that needs to be tested for
 779                // alert conditions.  Do that now, and when we're done, set
 780                // its next query-time to some distance in the future.
 781                //
 782                if (lpoa->dwTickNextRefresh == 0)
 783                   {
 784                   if (lpoa->cTickRefresh != 0)
 785                      lpoa->dwTickNextRefresh = lpoa->cTickRefresh + GetTickCount();
 786                   }
 787                else if (lpoa->dwTickNextRefresh <= GetTickCount())
 788                   {
 789                   (void)lpServer->Invalidate();
 790                   (void)lpServer->RefreshAll();
 791                   lpoa->dwTickNextRefresh = lpoa->cTickRefresh + GetTickCount();
 792                   }
 793
 794                (void)Alert_Scout_CheckServer (lpServer);
 795                }
 796
 797             lpServer->Close();
 798             }
 799
 800          lpCell->Close();
 801          }
 802
 803       AfsClass_Leave();
 804
 805       // Now that we have completed a pass over the servers in this cell,
 806       // and now that we're not holding any critical sections on which
 807       // other threads would otherwise block, go to sleep for a while.
 808       //
 809       WaitForSingleObjectEx (heScoutWakeup, 45L * cmsec1SECOND, FALSE);
 810       }
 811
 812    return 0;
 813 }
 814
 815
 816 void Alert_Scout_SetOutOfDate (LPIDENT lpi)
 817 {
 818    LPOBJECTALERTS lpoa;
 819    if ((lpoa = Alert_GetObjectAlerts (lpi, TRUE)) != NULL)
 820       {
 821       lpoa->dwTickNextTest = GetTickCount() -1;
 822       }
 823 }
 824
 825
 826 void Alert_Scout_SetUpToDate (LPOBJECTALERTS lpoa)
 827 {
 828    if (lpoa != NULL)
 829       {
 830       lpoa->dwTickNextTest = GetTickCount() + lpoa->cTickRefresh;
 831       }
 832 }
 833
 834
 835 BOOL Alert_Scout_CheckServer (LPSERVER lpServer)
 836 {
 837    BOOL rc = TRUE;
 838
 839    LPSERVER_PREF lpsp;
 840    if ((lpsp = (LPSERVER_PREF)lpServer->GetUserParam()) != NULL)
 841       {
 842       LPOBJECTALERTS lpoa;
 843       if ((lpoa = Alert_GetObjectAlerts (lpServer->GetIdentifier())) != NULL)
 844          {
 845          PostNotification (evtScoutBegin, lpServer->GetIdentifier());
 846
 847          BOOL fChangedServerAlerts = FALSE;
 848
 849          DWORD dwTickNextTestWhenStarted = lpoa->dwTickNextTest;
 850
 851          // First look through the server's aggregates and filesets, to
 852          // find any which have usages over their warning threshholds.
 853          //
 854          HENUM heAggregate;
 855          for (LPAGGREGATE lpAggregate = lpServer->AggregateFindFirst (&heAggregate); lpAggregate; lpAggregate = lpServer->AggregateFindNext (&heAggregate))
 856             {
 857             BOOL fChangedAggregateAlerts = FALSE;
 858             LPIDENT lpiAggregate = lpAggregate->GetIdentifier();
 859
 860             LPOBJECTALERTS lpoaAggregate;
 861             if ((lpoaAggregate = Alert_GetObjectAlerts (lpAggregate->GetIdentifier())) != NULL)
 862                {
 863                for (size_t iAlert = 0; iAlert < lpoaAggregate->nAlerts; )
 864                   {
 865                   if ( (lpoaAggregate->aAlerts[ iAlert ].alert == alertFULL) ||
 866                        (lpoaAggregate->aAlerts[ iAlert ].alert == alertOVERALLOC) ||
 867                        (lpoaAggregate->aAlerts[ iAlert ].alert == alertNO_SVRENT) )
 868                      {
 869                      fChangedAggregateAlerts = TRUE;
 870                      fChangedServerAlerts = TRUE;
 871                      Alert_Remove (lpAggregate->GetIdentifier(), iAlert);
 872                      }
 873                   else
 874                      ++iAlert;
 875                   }
 876
 877                LPAGGREGATE_PREF lpap;
 878                if ((lpap = (LPAGGREGATE_PREF)lpAggregate->GetUserParam()) != NULL)
 879                   {
 880                   short wGhost = lpAggregate->GetGhostStatus();
 881                   if (lpsp->fWarnAggNoServ && !(wGhost & GHOST_HAS_SERVER_ENTRY))
 882                      {
 883                      ALERTINFO ai;
 884                      ai.alert = alertNO_SVRENT;
 885                      Alert_AddPrimary (lpAggregate->GetIdentifier(), &ai);
 886                      fChangedAggregateAlerts = TRUE;
 887                      fChangedServerAlerts = TRUE;
 888                      }
 889
 890                   if (lpsp->fWarnAggAlloc && lpap->fWarnAggAlloc)
 891                      {
 892                      AGGREGATESTATUS as;
 893                      if (lpAggregate->GetStatus (&as, TRUE))
 894                         {
 895                         if (as.ckStorageAllocated > as.ckStorageTotal)
 896                            {
 897                            ALERTINFO ai;
 898                            ai.alert = alertOVERALLOC;
 899                            ai.aiOVERALLOC.ckAllocated = as.ckStorageAllocated;
 900                            ai.aiOVERALLOC.ckCapacity = as.ckStorageTotal;
 901                            Alert_AddPrimary (lpAggregate->GetIdentifier(), &ai);
 902                            fChangedAggregateAlerts = TRUE;
 903                            fChangedServerAlerts = TRUE;
 904                            }
 905                         }
 906                      }
 907
 908                   short perWarnAggFull = lpap->perWarnAggFull;
 909                   if (perWarnAggFull == -1)
 910                      perWarnAggFull = lpsp->perWarnAggFull;
 911                   if (perWarnAggFull != 0)
 912                      {
 913                      AGGREGATESTATUS as;
 914                      if (lpAggregate->GetStatus (&as, TRUE))
 915                         {
 916                         if (as.ckStorageTotal != 0)
 917                            {
 918                            short perNow = (short)( (double)(as.ckStorageTotal - as.ckStorageFree) * 100.0 / (double)(as.ckStorageTotal) );
 919
 920                            if (perNow > perWarnAggFull)
 921                               {
 922                               ALERTINFO ai;
 923                               ai.alert = alertFULL;
 924                               ai.aiFULL.perWarning = perWarnAggFull;
 925                               ai.aiFULL.ckWarning = (ULONG)( (double)perWarnAggFull * (double)(as.ckStorageTotal) / 100.0 );
 926                               Alert_AddPrimary (lpAggregate->GetIdentifier(), &ai);
 927                               fChangedAggregateAlerts = TRUE;
 928                               fChangedServerAlerts = TRUE;
 929                               }
 930                            }
 931                         }
 932                      }
 933                   }
 934                }
 935
 936             HENUM heFileset;
 937             for (LPFILESET lpFileset = lpAggregate->FilesetFindFirst (&heFileset); lpFileset; lpFileset = lpAggregate->FilesetFindNext (&heFileset))
 938                {
 939                BOOL fChangedFilesetAlerts = FALSE;
 940                LPIDENT lpiFileset = lpFileset->GetIdentifier();
 941
 942                LPOBJECTALERTS lpoaFileset;
 943                if ((lpoaFileset = Alert_GetObjectAlerts (lpFileset->GetIdentifier())) != NULL)
 944                   {
 945                   for (size_t iAlert = 0; iAlert < lpoaFileset->nAlerts; )
 946                      {
 947                      if ( (lpoaFileset->aAlerts[ iAlert ].alert == alertFULL) ||
 948                           (lpoaFileset->aAlerts[ iAlert ].alert == alertSTATE_NO_VNODE) ||
 949                           (lpoaFileset->aAlerts[ iAlert ].alert == alertSTATE_NO_SERVICE) ||
 950                           (lpoaFileset->aAlerts[ iAlert ].alert == alertSTATE_OFFLINE) ||
 951                           (lpoaFileset->aAlerts[ iAlert ].alert == alertNO_VLDBENT) ||
 952                           (lpoaFileset->aAlerts[ iAlert ].alert == alertNO_SVRENT) )
 953                         {
 954                         fChangedFilesetAlerts = TRUE;
 955                         fChangedServerAlerts = TRUE;
 956                         Alert_Remove (lpFileset->GetIdentifier(), iAlert);
 957                         }
 958                      else
 959                         ++iAlert;
 960                      }
 961                   }
 962
 963                LPFILESET_PREF lpfp;
 964                if ((lpfp = (LPFILESET_PREF)lpFileset->GetUserParam()) != NULL)
 965                   {
 966                   FILESETSTATUS fs;
 967                   if (lpFileset->GetStatus (&fs, TRUE))
 968                      {
 969                      if (fs.State & fsNO_VNODE)
 970                         {
 971                         ALERTINFO ai;
 972                         ai.alert = alertSTATE_NO_VNODE;
 973                         ai.aiSTATE.State = fs.State;
 974                         Alert_AddPrimary (lpFileset->GetIdentifier(), &ai);
 975                         fChangedFilesetAlerts = TRUE;
 976                         fChangedServerAlerts = TRUE;
 977                         }
 978                      else if (fs.State & fsNO_SERVICE)
 979                         {
 980                         ALERTINFO ai;
 981                         ai.alert = alertSTATE_NO_SERVICE;
 982                         ai.aiSTATE.State = fs.State;
 983                         Alert_AddPrimary (lpFileset->GetIdentifier(), &ai);
 984                         fChangedFilesetAlerts = TRUE;
 985                         fChangedServerAlerts = TRUE;
 986                         }
 987                      else if (fs.State & fsOFFLINE)
 988                         {
 989                         ALERTINFO ai;
 990                         ai.alert = alertSTATE_OFFLINE;
 991                         ai.aiSTATE.State = fs.State;
 992                         Alert_AddPrimary (lpFileset->GetIdentifier(), &ai);
 993                         fChangedFilesetAlerts = TRUE;
 994                         fChangedServerAlerts = TRUE;
 995                         }
 996
 997                      short perWarnSetFull = lpfp->perWarnSetFull;
 998                      if (perWarnSetFull == -1)
 999                         perWarnSetFull = lpsp->perWarnSetFull;
1000                      if (perWarnSetFull != 0)
1001                         {
1002                         if (fs.Type == ftREADWRITE)
1003                            {
1004                            if (fs.ckQuota != 0)
1005                               {
1006                               short perNow = (short)( (double)(fs.ckUsed) * 100.0 / (double)(fs.ckQuota) );
1007
1008                               if (perNow > perWarnSetFull)
1009                                  {
1010                                  ALERTINFO ai;
1011                                  ai.alert = alertFULL;
1012                                  ai.aiFULL.perWarning = perWarnSetFull;
1013                                  ai.aiFULL.ckWarning = (ULONG)( (double)perWarnSetFull * (double)(fs.ckQuota) / 100.0 );
1014                                  Alert_AddPrimary (lpFileset->GetIdentifier(), &ai);
1015                                  fChangedFilesetAlerts = TRUE;
1016                                  fChangedServerAlerts = TRUE;
1017                                  }
1018                               }
1019                            }
1020                         }
1021                      }
1022
1023                   short wGhost = lpFileset->GetGhostStatus();
1024                   if (lpsp->fWarnSetNoVLDB && !(wGhost & GHOST_HAS_VLDB_ENTRY))
1025                      {
1026                      ALERTINFO ai;
1027                      ai.alert = alertNO_VLDBENT;
1028                      Alert_AddPrimary (lpFileset->GetIdentifier(), &ai);
1029                      fChangedFilesetAlerts = TRUE;
1030                      fChangedServerAlerts = TRUE;
1031                      }
1032                   if (lpsp->fWarnSetNoServ && !(wGhost & GHOST_HAS_SERVER_ENTRY) && !(fs.Type == ftREPLICA))
1033                      {
1034                      ALERTINFO ai;
1035                      ai.alert = alertNO_SVRENT;
1036                      Alert_AddPrimary (lpFileset->GetIdentifier(), &ai);
1037                      fChangedFilesetAlerts = TRUE;
1038                      fChangedServerAlerts = TRUE;
1039                      }
1040                   }
1041
1042                lpFileset->Close();
1043                if (fChangedFilesetAlerts)
1044                   {
1045                   PostNotification (evtAlertsChanged, lpiFileset);
1046                   }
1047                }
1048
1049             lpAggregate->Close();
1050             if (fChangedAggregateAlerts)
1051                {
1052                PostNotification (evtAlertsChanged, lpiAggregate);
1053                }
1054             }
1055
1056          // Next look through the server's servces to find any
1057          // which have stopped.
1058          //
1059          HENUM heService;
1060          for (LPSERVICE lpService = lpServer->ServiceFindFirst (&heService); lpService; lpService = lpServer->ServiceFindNext (&heService))
1061             {
1062             BOOL fChangedServiceAlerts = FALSE;
1063             LPIDENT lpiService = lpService->GetIdentifier();
1064
1065             LPOBJECTALERTS lpoaService;
1066             if ((lpoaService = Alert_GetObjectAlerts (lpService->GetIdentifier())) != NULL)
1067                {
1068                for (size_t iAlert = 0; iAlert < lpoaService->nAlerts; )
1069                   {
1070                   if (lpoaService->aAlerts[ iAlert ].alert == alertSTOPPED)
1071                      {
1072                      fChangedServiceAlerts = TRUE;
1073                      fChangedServerAlerts = TRUE;
1074                      Alert_Remove (lpService->GetIdentifier(), iAlert);
1075                      }
1076                   else
1077                      ++iAlert;
1078                   }
1079
1080                LPSERVICE_PREF lpcp;
1081                if ((lpcp = (LPSERVICE_PREF)lpService->GetUserParam()) != NULL)
1082                   {
1083                   if (lpcp->fWarnSvcStop && lpsp->fWarnSvcStop)
1084                      {
1085                      SERVICESTATUS ss;
1086                      if (lpService->GetStatus (&ss, TRUE))
1087                         {
1088                         if (ss.state != SERVICESTATE_RUNNING)
1089                            {
1090                            ALERTINFO ai;
1091                            ai.alert = alertSTOPPED;
1092                            memcpy (&ai.aiSTOPPED.stStopped,   &ss.timeLastStop, sizeof(SYSTEMTIME));
1093                            memcpy (&ai.aiSTOPPED.stLastError, &ss.timeLastFail, sizeof(SYSTEMTIME));
1094                            ai.aiSTOPPED.errLastError = ss.dwErrLast;
1095                            Alert_AddPrimary (lpService->GetIdentifier(), &ai);
1096                            fChangedServiceAlerts = TRUE;
1097                            fChangedServerAlerts = TRUE;
1098                            }
1099                         }
1100                      }
1101                   }
1102                }
1103
1104             lpService->Close();
1105             if (fChangedServiceAlerts)
1106                {
1107                PostNotification (evtAlertsChanged, lpiService);
1108                }
1109             }
1110
1111          if (rc && (dwTickNextTestWhenStarted == lpoa->dwTickNextTest))
1112             {
1113             Alert_Scout_SetUpToDate (lpoa);
1114             }
1115
1116          if (fChangedServerAlerts)
1117             {
1118             PostNotification (evtAlertsChanged, lpServer->GetIdentifier());
1119             }
1120
1121          PostNotification (evtScoutEnd, lpServer->GetIdentifier());
1122          }
1123       }
1124
1125    return rc;
1126 }
1127