archive
/
windows-xp
mirror of https://github.com/tongzx/nt5src
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6 Commits
1 Branch
0 Tags
2.0 GiB
 
 
 
 
 
 
Tree: daad8a087a
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'daad8a087a'
${ noResults }
windows-xp/Source/XPSP1/NT/net/mmc/wins/svrstats.cpp

750 lines
21 KiB
Raw Blame History

/**********************************************************************/
/** Microsoft Windows/NT **/
/** Copyright(c) Microsoft Corporation, 1997 - 1999 **/
/**********************************************************************/
/*
ServStat.cpp
The server statistics dialog
FILE HISTORY:
*/
#include <afx.h>
#include "dbgutil.h"
#include "stdafx.h"
#include "winssnap.h"
#include "server.h"
#include "resource.h"
#include "svrstats.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
#define INTLTIMESTR(time) (((CIntlTime)(time)).CIntlTime::operator const CString())
#define TMST1(x) INTLTIMESTR((m_wrResults).WinsStat.TimeStamps.x)
#define INTLNUMSTR(num) (((CIntlNumber)(num)).CIntlNumber::operator const CString())
#define TCTR(x) INTLNUMSTR((m_wrResults).WinsStat.Counters.x)
#define STATMUTEXNAME _T("WINSADMNGETSTATISTICS")
#define WM_UPDATE_STATS WM_USER + 1099
enum
{
SERVER_STAT_START_TIME = 0,
SERVER_STAT_DB_INIT_TIME,
SERVER_STAT_STAT_CLEAR_TIME,
SERVER_STAT_BLANK0,
SERVER_STAT_LAST_PERIODIC_REP,
SERVER_STAT_LAST_ADMIN_REP,
SERVER_STAT_LAST_NET_UPDATE_REP,
SERVER_STAT_LAST_ADDRESS_CHANGE_REP,
SERVER_STAT_BLANK1,
SERVER_STAT_TOTAL_QUERIES,
SERVER_STAT_SUCCESSFUL_QUERRIES,
SERVER_STAT_FAILED_QUERRIES,
SERVER_STAT_BLANK2,
SERVER_STAT_TOTAL_RELEASES,
SERVER_STAT_SUCCESSFUL_RELEASES,
SERVER_STAT_FAILED_RELEASES,
SERVER_STAT_BLANK3,
SERVER_STAT_UNIQUE_REGISTRATIONS,
SERVER_STAT_UNIQUE_CONFLICTS,
SERVER_STAT_UNIQUE_RENEWALS,
SERVER_STAT_BLANK4,
SERVER_STAT_GROUP_REGISTRATIONS,
SERVER_STAT_GROUP_CONFLICTS,
SERVER_STAT_GROUP_RENEWALS,
SERVER_STAT_BLANK5,
SERVER_STAT_TOTAL_REG,
SERVER_STAT_BLANK6,
SERVER_STAT_LAST_PERIODIC_SCAV,
SERVER_STAT_LAST_ADMIN_SCAV,
SERVER_STAT_LAST_EXTINCTION_SCAV,
SERVER_STAT_LAST_VERIFICATION_SCAV,
SERVER_STAT_BLANK7,
SERVER_STAT_PARTNERS_HEADER,
SERVER_STAT_MAX
};
/*---------------------------------------------------------------------------
CServerStatsFrame implementation
---------------------------------------------------------------------------*/
const ContainerColumnInfo s_rgServerStatsColumnInfo[] =
{
{ IDS_SERVER_STATS_START_TIME, 0, TRUE },
{ IDS_SERVER_STATS_DB_INIT_TIME, 0, TRUE },
{ IDS_SERVER_STATS_LAST_CLEAR_TIME, 0, TRUE },
{ IDS_BLANK, 0, TRUE },
{ IDS_SERVER_STATS_LAST_PREP, 0, TRUE },
{ IDS_SERVER_STATS_LAST_AREP, 0, TRUE },
{ IDS_SERVER_STATS_LAST_NREP, 0, TRUE },
{ IDS_SERVER_STATS_LAST_ACREP, 0, TRUE },
{ IDS_BLANK, 0, TRUE },
{ IDS_SERVER_STATS_TOTAL_QUERRIES, 0, TRUE },
{ IDS_SERVER_STATS_SUCCESSFUL, 0, TRUE },
{ IDS_SERVER_STATS_FAILED, 0, TRUE },
{ IDS_BLANK, 0, TRUE },
{ IDS_SERVER_STATS_TOTAL_RELEASES, 0, TRUE },
{ IDS_SERVER_STATS_SUCCESSFUL, 0, TRUE },
{ IDS_SERVER_STATS_FAILED, 0, TRUE },
{ IDS_BLANK, 0, TRUE },
{ IDS_SERVER_STATS_UNIQUE_REGISTRATIONS, 0, TRUE },
{ IDS_SERVER_STATS_CONFLICTS, 0, TRUE },
{ IDS_SERVER_STATS_RENEWALS, 0, TRUE },
{ IDS_BLANK, 0, TRUE },
{ IDS_SERVER_STATS_GROUP_REGISTRATIONS, 0, TRUE },
{ IDS_SERVER_STATS_CONFLICTS, 0, TRUE },
{ IDS_SERVER_STATS_RENEWALS, 0, TRUE },
{ IDS_BLANK, 0, TRUE },
{ IDS_SERVER_STATS_TOTAL_REGISTRATIONS, 0, TRUE },
{ IDS_BLANK, 0, TRUE },
{ IDS_SERVER_STATS_LAST_PSCAV, 0, TRUE },
{ IDS_SERVER_STATS_LAST_ASCAV, 0, TRUE },
{ IDS_SERVER_STATS_LAST_ESCAV, 0, TRUE },
{ IDS_SERVER_STATS_LAST_VSCAV, 0, TRUE },
{ IDS_BLANK, 0, TRUE },
{ IDS_SERVER_STATS_PARTNERS_HEADER, 0, TRUE },
};
UINT _cdecl
RefreshStatsThread(LPVOID pParam)
{
DWORD dw;
ThreadInfo * pInfo = (ThreadInfo *)(pParam);
HANDLE hmutStatistics = NULL;
HRESULT hr = hrOK;
COM_PROTECT_TRY
{
// Open the existing mutex
while (hmutStatistics == NULL)
{
if ((hmutStatistics = ::OpenMutex(SYNCHRONIZE, FALSE, STATMUTEXNAME)) == NULL)
{
::Sleep(2000L);
}
}
// This is where the work gets done
for (;;)
{
pInfo->dwInterval = pInfo->pDlg->GetRefreshInterval();
//::Sleep((pInfo->dwInterval)*1000);
if (::WaitForSingleObject(pInfo->pDlg->m_hAbortEvent, (pInfo->dwInterval) * 1000) == WAIT_OBJECT_0)
{
// we're going away, lets get outta here
break;
}
// Wait until we get the go ahead
dw = ::WaitForSingleObject(hmutStatistics, INFINITE);
if (dw == WAIT_OBJECT_0)
{
dw = pInfo->pDlg->GetStats();
if (dw == ERROR_SUCCESS)
{
PostMessage(pInfo->pDlg->GetSafeHwnd(), WM_UPDATE_STATS, 0, 0);
}
::ReleaseMutex(hmutStatistics);
}
}
delete pInfo;
}
COM_PROTECT_CATCH
return 0;
}
/*---------------------------------------------------------------------------
CServerStatsFrame::CServerStatsFrame()
Constructor
---------------------------------------------------------------------------*/
CServerStatsFrame::CServerStatsFrame()
: StatsDialog(STATSDLG_VERTICAL|STATSDLG_CLEAR)
{
SetColumnInfo(s_rgServerStatsColumnInfo,
DimensionOf(s_rgServerStatsColumnInfo));
m_hmutStatistics = NULL;
m_hAbortEvent = NULL;
m_pRefreshThread = NULL;
ZeroMemory(&m_wrResults, sizeof(m_wrResults));
}
/*---------------------------------------------------------------------------
CServerStatsFrame::CServerStatsFrame()
Destructor
---------------------------------------------------------------------------*/
CServerStatsFrame::~CServerStatsFrame()
{
}
BEGIN_MESSAGE_MAP(CServerStatsFrame, StatsDialog)
//{{AFX_MSG_MAP(CServerStatistics)
//}}AFX_MSG_MAP
ON_MESSAGE(WM_NEW_STATS_AVAILABLE, OnNewStatsAvailable)
ON_MESSAGE(WM_UPDATE_STATS, OnUpdateStats)
ON_BN_CLICKED(IDC_STATSDLG_BTN_CLEAR, OnClear)
ON_WM_DESTROY()
END_MESSAGE_MAP()
/*---------------------------------------------------------------------------
CServerStatsFrame::CServerStatsFrame()
Gets the statistics from the server handler and updates the
internal variable m_wrResults
---------------------------------------------------------------------------*/
HRESULT CServerStatsFrame::RefreshData(BOOL fGrabNewData)
{
if (fGrabNewData)
{
DWORD dwError = 0;
BEGIN_WAIT_CURSOR;
dwError = GetStats();
END_WAIT_CURSOR;
if (dwError != ERROR_SUCCESS)
{
WinsMessageBox(dwError);
}
else
{
UpdateWindow(&m_wrResults);
}
}
return hrOK;
}
DWORD CServerStatsFrame::GetStats()
{
DWORD dwError = 0;
SPITFSNode spNode;
PWINSINTF_RESULTS_T pResults = NULL;
CWinsServerHandler * pServer;
pServer = GETHANDLER(CWinsServerHandler, m_spNode);
dwError = pServer->GetStatistics(m_spNode, &pResults);
if (dwError == ERROR_SUCCESS)
{
m_wrResults = *(pResults);
}
return dwError;
}
BOOL CServerStatsFrame::OnInitDialog()
{
CString st;
BOOL bRet;
AfxFormatString1(st, IDS_SERVER_STATS_TITLE, m_strServerAddress);
SetWindowText((LPCTSTR) st);
bRet = StatsDialog::OnInitDialog();
// add the blank column because the replication partner stats need them
m_listCtrl.InsertColumn(2, _T(" "), LVCFMT_LEFT, 100);
// Set the default column widths to the width of the widest column
SetColumnWidths(2 /* Number of Columns */);
UpdateWindow(&m_wrResults);
// set the default window size
RECT rect;
GetWindowRect(&rect);
int nWidth = 0;
for (int i = 0; i < 3; i++)
{
nWidth += m_listCtrl.GetColumnWidth(i);
}
SetWindowPos(NULL, rect.left, rect.top, nWidth + 20, SERVER_STATS_DEFAULT_HEIGHT, SWP_SHOWWINDOW);
if ((m_hmutStatistics = ::CreateMutex(NULL, FALSE, STATMUTEXNAME)) == NULL)
{
Trace1("CServerStatsFrame::OnInitDialog() - CreateMutex failed! %lx\n", GetLastError());
return FALSE;
}
if ((m_hAbortEvent = ::CreateEvent(NULL, FALSE, FALSE, NULL)) == NULL)
{
Trace1("CServerStatsFrame::OnInitDialog() - CreateEvent failed! %lx\n", GetLastError());
return FALSE;
}
StartRefresherThread();
return bRet;
}
void CServerStatsFrame::Sort(UINT nColumnId)
{
// we don't sort any of our stats
}
/*---------------------------------------------------------------------------
CServerStatsFrame::OnNewStatsAvailable(UINT wParam, LONG lParam)
called in response to the message ON_NEW_STATS_AVAILABLE
Author: EricDav
---------------------------------------------------------------------------*/
afx_msg long
CServerStatsFrame::OnNewStatsAvailable(UINT wParam, LONG lParam)
{
DWORD dwErr = GetStats();
if (dwErr == ERROR_SUCCESS)
{
UpdateWindow(&m_wrResults);
}
else
{
WinsMessageBox(dwErr);
}
return 0;
}
/*---------------------------------------------------------------------------
CServerStatsFrame::OnNewStatsAvailable(UINT wParam, LONG lParam)
called in response to the message WM_UPDATE_STATS
The background thread updates the stats, now we need to update
the UI on the correct thread.
Author: EricDav
---------------------------------------------------------------------------*/
afx_msg long
CServerStatsFrame::OnUpdateStats(UINT wParam, LONG lParam)
{
UpdateWindow(&m_wrResults);
return 0;
}
/*---------------------------------------------------------------------------
CServerStatsFrame::UpdateWindow(PWINSINTF_RESULTS_T pwrResults)
Updates the contents of the dialog
---------------------------------------------------------------------------*/
void
CServerStatsFrame::UpdateWindow(PWINSINTF_RESULTS_T pwrResults)
{
SPITFSNode spNode;
CWinsServerHandler * pServer;
CString str;
UINT i;
int nTotalAddresses = 0, nTotalInUse = 0, nTotalAvailable = 0;
// now fill in the data
for (i = 0; i < SERVER_STAT_MAX; i++)
{
if (!pwrResults)
str = _T("---");
else
{
switch (i)
{
// server stsrt time
case SERVER_STAT_START_TIME:
{
CTime timeStart(m_wrResults.WinsStat.TimeStamps.WinsStartTime);
if(timeStart != 0)
FormatDateTime(str, &m_wrResults.WinsStat.TimeStamps.WinsStartTime);
else
str.LoadString(IDS_INVALID_TIME);
}
break;
// database initialized time
case SERVER_STAT_DB_INIT_TIME:
{
CTime timeStart(m_wrResults.WinsStat.TimeStamps.LastInitDbTime);
if(timeStart != 0)
FormatDateTime(str, &m_wrResults.WinsStat.TimeStamps.LastInitDbTime);
else
str.LoadString(IDS_INVALID_TIME);
}
break;
// statistics last cleared time
case SERVER_STAT_STAT_CLEAR_TIME:
{
CTime timeStart(m_wrResults.WinsStat.TimeStamps.CounterResetTime);
if(timeStart != 0)
FormatDateTime(str, &m_wrResults.WinsStat.TimeStamps.CounterResetTime);
else
str.LoadString(IDS_INVALID_TIME);
}
break;
// some blank lines in between
case SERVER_STAT_BLANK0:
case SERVER_STAT_BLANK1:
case SERVER_STAT_BLANK2:
case SERVER_STAT_BLANK3:
case SERVER_STAT_BLANK4:
case SERVER_STAT_BLANK5:
case SERVER_STAT_BLANK6:
case SERVER_STAT_BLANK7:
str = _T("");
break;
case SERVER_STAT_LAST_PERIODIC_REP:
{
CTime timeStart(m_wrResults.WinsStat.TimeStamps.LastPRplTime);
if(timeStart != 0)
FormatDateTime(str, &m_wrResults.WinsStat.TimeStamps.LastPRplTime);
else
str.LoadString(IDS_INVALID_TIME);
}
break;
case SERVER_STAT_LAST_ADMIN_REP:
{
CTime timeStart(m_wrResults.WinsStat.TimeStamps.LastATRplTime);
if(timeStart != 0)
FormatDateTime(str, &m_wrResults.WinsStat.TimeStamps.LastATRplTime);
else
str.LoadString(IDS_INVALID_TIME);
}
break;
case SERVER_STAT_LAST_NET_UPDATE_REP:
{
CTime timeStart(m_wrResults.WinsStat.TimeStamps.LastNTRplTime);
if(timeStart != 0)
FormatDateTime(str, &m_wrResults.WinsStat.TimeStamps.LastNTRplTime);
else
str.LoadString(IDS_INVALID_TIME);
}
break;
// last address changed time
case SERVER_STAT_LAST_ADDRESS_CHANGE_REP:
{
CTime timeStart(m_wrResults.WinsStat.TimeStamps.LastACTRplTime);
if(timeStart != 0)
FormatDateTime(str, &m_wrResults.WinsStat.TimeStamps.LastACTRplTime);
else
str.LoadString(IDS_INVALID_TIME);
}
break;
// total queries received
case SERVER_STAT_TOTAL_QUERIES:
str = TCTR(NoOfQueries);
break;
// successful queries
case SERVER_STAT_SUCCESSFUL_QUERRIES:
str = TCTR(NoOfSuccQueries);
break;
// Queries that failed
case SERVER_STAT_FAILED_QUERRIES:
str = TCTR(NoOfFailQueries);
break;
case SERVER_STAT_TOTAL_RELEASES:
str = TCTR(NoOfRel);
break;
case SERVER_STAT_SUCCESSFUL_RELEASES:
str = TCTR(NoOfSuccRel);
break;
case SERVER_STAT_FAILED_RELEASES:
str = TCTR(NoOfFailRel);
break;
// unique registrations
case SERVER_STAT_UNIQUE_REGISTRATIONS:
str = TCTR(NoOfUniqueReg);
break;
case SERVER_STAT_UNIQUE_CONFLICTS:
str = TCTR(NoOfUniqueCnf);
break;
case SERVER_STAT_UNIQUE_RENEWALS:
str = TCTR(NoOfUniqueRef);
break;
// group registrations
case SERVER_STAT_GROUP_REGISTRATIONS:
str = TCTR(NoOfGroupReg);
break;
case SERVER_STAT_GROUP_CONFLICTS:
str = TCTR(NoOfGroupCnf);
break;
case SERVER_STAT_GROUP_RENEWALS:
str = TCTR(NoOfGroupRef);
break;
// total registrations
case SERVER_STAT_TOTAL_REG:
str = INTLNUMSTR(m_wrResults.WinsStat.Counters.NoOfGroupReg +
m_wrResults.WinsStat.Counters.NoOfUniqueReg);
break;
case SERVER_STAT_LAST_PERIODIC_SCAV:
{
CTime timeStart(m_wrResults.WinsStat.TimeStamps.LastPScvTime);
if(timeStart != 0)
FormatDateTime(str, &m_wrResults.WinsStat.TimeStamps.LastPScvTime);
else
str.LoadString(IDS_INVALID_TIME);
}
break;
case SERVER_STAT_LAST_ADMIN_SCAV:
{
CTime timeStart(m_wrResults.WinsStat.TimeStamps.LastATScvTime);
if(timeStart != 0)
FormatDateTime(str, &m_wrResults.WinsStat.TimeStamps.LastATScvTime);
else
str.LoadString(IDS_INVALID_TIME);
}
break;
case SERVER_STAT_LAST_EXTINCTION_SCAV:
{
CTime timeStart(m_wrResults.WinsStat.TimeStamps.LastTombScvTime);
if(timeStart != 0)
FormatDateTime(str, &m_wrResults.WinsStat.TimeStamps.LastTombScvTime);
else
str.LoadString(IDS_INVALID_TIME);
}
break;
case SERVER_STAT_LAST_VERIFICATION_SCAV:
{
CTime timeStart(m_wrResults.WinsStat.TimeStamps.LastVerifyScvTime);
if(timeStart != 0)
FormatDateTime(str, &m_wrResults.WinsStat.TimeStamps.LastVerifyScvTime);
else
str.LoadString(IDS_INVALID_TIME);
}
break;
case SERVER_STAT_PARTNERS_HEADER:
{
str.LoadString(IDS_SERVER_STATS_NO_OF_FAILED);
m_listCtrl.SetItemText(i, 2, (LPCTSTR) str);
str.LoadString(IDS_SERVER_STATS_NO_OF_REPLS);
}
break;
default:
Assert("Invalid server statistic type!");
break;
}
}
// now the string is set, display in the dlg
m_listCtrl.SetItemText(i, 1, (LPCTSTR) str);
}
UpdatePartnerStats();
}
/*---------------------------------------------------------------------------
CServerStatsFrame::StartRefresherThread()
Starts the refresher thread, called as soon as the dilog is
brought up
---------------------------------------------------------------------------*/
void
CServerStatsFrame::StartRefresherThread()
{
ThreadInfo *info = new ThreadInfo;
CWinsServerHandler * pServer;
pServer = GETHANDLER(CWinsServerHandler, m_spNode);
info->dwInterval = pServer->m_dwRefreshInterval;
info->pDlg = this;
m_pRefreshThread = ::AfxBeginThread(RefreshStatsThread, info);
if (m_pRefreshThread == NULL)
{
Trace0("Failed to create thread\n");
m_pRefreshThread = NULL;
return;
}
Trace0("Auto refresh thread succesfully started\n");
}
/*---------------------------------------------------------------------------
CServerStatsFrame::ReInitRefresherThread()
If the refresher thread was running, re-start it. It is needed
in order to pick on the fly the new refresh intervals
---------------------------------------------------------------------------*/
void
CServerStatsFrame::ReInitRefresherThread()
{
// if there is a refresher thread, just restart it
if (m_pRefreshThread != NULL)
{
KillRefresherThread();
StartRefresherThread();
}
}
/*---------------------------------------------------------------------------
CServerStatsFrame::KillRefresherThread()
Kills the refresh data thread, caled when the dlg is destroyed
---------------------------------------------------------------------------*/
void
CServerStatsFrame::KillRefresherThread()
{
//
// Kill refresher thread if necessary.
//
if (m_pRefreshThread == NULL)
{
//
// No thread running
//
return;
}
//::TerminateThread(m_pRefreshThread->m_hThread, 0);
//::CloseHandle(m_pRefreshThread->m_hThread);
::SetEvent(m_hAbortEvent);
::WaitForSingleObject(m_pRefreshThread->m_hThread, 5000);
m_pRefreshThread = NULL;
}
/*---------------------------------------------------------------------------
CServerStatsFrame::OnDestroy( )
Message Handler
---------------------------------------------------------------------------*/
void
CServerStatsFrame::OnDestroy( )
{
KillRefresherThread();
if (m_hmutStatistics)
{
::CloseHandle(m_hmutStatistics);
m_hmutStatistics = NULL;
}
if (m_hAbortEvent)
{
::CloseHandle(m_hAbortEvent);
m_hAbortEvent = NULL;
}
}
/*---------------------------------------------------------------------------
CServerStatsFrame::GetRefreshInterval()
Returns the refresh interval, stored in the server handler
---------------------------------------------------------------------------*/
DWORD
CServerStatsFrame::GetRefreshInterval()
{
CWinsServerHandler * pServer;
pServer = GETHANDLER(CWinsServerHandler, m_spNode);
return pServer->m_dwRefreshInterval;
}
/*---------------------------------------------------------------------------
CServerStatsFrame::OnClear()
Calls the wins api to reset counters and updates data, in response to
click of the clear button
---------------------------------------------------------------------------*/
void
CServerStatsFrame::OnClear()
{
DWORD dwErr = ERROR_SUCCESS;
CWinsServerHandler * pServer = GETHANDLER(CWinsServerHandler, m_spNode);
// clear the ststistics
BEGIN_WAIT_CURSOR
dwErr = pServer->ClearStatistics(m_spNode);
END_WAIT_CURSOR
if (dwErr == ERROR_SUCCESS)
{
// refresh the data now
RefreshData(TRUE);
UpdateWindow(&m_wrResults);
}
else
{
WinsMessageBox(dwErr);
}
}
/*---------------------------------------------------------------------------
CServerStatsFrame::UpdatePartnerStats()
---------------------------------------------------------------------------*/
void
CServerStatsFrame::UpdatePartnerStats()
{
UINT i, uCount;
CString strText;
// first remove all old partner info
uCount = m_listCtrl.GetItemCount();
for (i = 0; i < (uCount - SERVER_STAT_MAX); i++)
{
m_listCtrl.DeleteItem(SERVER_STAT_MAX);
}
int nPartner = 0;
// now add all of the partner information in
for (i = SERVER_STAT_MAX; i < SERVER_STAT_MAX + m_wrResults.WinsStat.NoOfPnrs; i++)
{
m_listCtrl.InsertItem(i, _T(""));
// ip address
::MakeIPAddress(m_wrResults.WinsStat.pRplPnrs[nPartner].Add.IPAdd, strText);
m_listCtrl.SetItemText(i, 0, strText);
// replication count
strText.Format(_T("%d"), m_wrResults.WinsStat.pRplPnrs[nPartner].NoOfRpls);
m_listCtrl.SetItemText(i, 1, strText);
// failed count
strText.Format(_T("%d"), m_wrResults.WinsStat.pRplPnrs[nPartner].NoOfCommFails);
m_listCtrl.SetItemText(i, 2, strText);
nPartner++;
}
}