dubey/WindowsXP
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
WindowsXP/inetsrv/iis/admin/snapin/app_pool_sheet.cpp
Tanishq Dubey cb60ae51e5
Initial Commit
2025-04-27 07:49:33 -04:00

1633 lines
48 KiB
C++
Raw Permalink Blame History

/*++
Copyright (c) 1994-2000 Microsoft Corporation
Module Name :
app_pool_sheet.cpp
Abstract:
Application Pools Property Sheet and Pages
Author:
Sergei Antonov (sergeia)
Project:
Internet Services Manager
Revision History:
11/16/2000 sergeia Initial creation
--*/
//
// Include Files
//
#include "stdafx.h"
#include "common.h"
#include "inetprop.h"
#include "InetMgrApp.h"
#include "shts.h"
#include "iisobj.h"
#include "app_pool_sheet.h"
#ifdef _DEBUG
#undef THIS_FILE
static char BASED_CODE THIS_FILE[] = __FILE__;
#endif
#define new DEBUG_NEW
#define TIMESPAN_MIN (int)1
#define TIMESPAN_MAX (int)(4000000)
#define REQUESTS_MIN (int)1
#define REQUESTS_MAX (int)(4000000)
#define MEMORY_MIN (int)1
#define MEMORY_MAX (int)(4000000)
#define TIMEOUT_MIN (int)1
#define TIMEOUT_MAX (int)(4000000)
#define QUEUESIZE_MIN (int)0
#define QUEUESIZE_MAX (int)(4000000)
#define REFRESH_TIME_MIN (int)1
#define REFRESH_TIME_MAX (int)(4000000)
#define MAXPROCESSES_MIN (int)1
#define MAXPROCESSES_MAX (int)(4000000)
#define PING_INTERVAL_MIN (int)1
#define PING_INTERVAL_MAX (int)(4000000)
#define CRASHES_COUNT_MIN (int)1
#define CRASHES_COUNT_MAX (int)(4000000)
#define CHECK_INTERVAL_MIN (int)1
#define CHECK_INTERVAL_MAX (int)(4000000)
#define STARTUP_LIMIT_MIN (int)1
#define STARTUP_LIMIT_MAX (int)(4000000)
#define SHUTDOWN_LIMIT_MIN (int)1
#define SHUTDOWN_LIMIT_MAX (int)(4000000)
#define CPU_LIMIT_MIN (int)0
#define CPU_LIMIT_MAX (int)100
#define CPU_RESET_TIME_MIN (int)0
#define CPU_RESET_TIME_MAX (int)60
#define IDENT_TYPE_LOCALSYSTEM 0
#define IDENT_TYPE_LOCALSERVICE 1
#define IDENT_TYPE_NETWORKSERVICE 2
#define IDENT_TYPE_CONFIGURABLE 3
#define PERIODIC_RESTART_TIME_DEF 60
#define PERIODIC_RESTART_REQ_DEF 10000
#define MEMORY_DEF 1 // In MB
#define IDLE_TIMEOUT_DEF 10
#define QUEUE_SIZE_DEF 3000
#define CPU_USE_DEF 10000
#define CPU_RESET_TIME_DEF 5
#define ACTION_INDEX_DEF IDENT_TYPE_NETWORKSERVICE
#define MAX_PROCESSES_DEF 1
#define PING_INTERVAL_DEF 120
#define CRASHES_COUNT_DEF 5
#define CHECK_INTERVAL_DEF 10
#define STARTUP_LIMIT_DEF 30
#define SHUTDOWN_LIMIT_DEF 60
/////////////////////////////////////////////////////////////////////////////
// CAppPoolProps implementation
CAppPoolProps::CAppPoolProps(
CComAuthInfo * pAuthInfo, LPCTSTR meta_path
)
: CMetaProperties(pAuthInfo, meta_path)
{
InitDefaults();
}
CAppPoolProps::CAppPoolProps(
CMetaInterface * pInterface, LPCTSTR meta_path
)
: CMetaProperties(pInterface, meta_path)
{
InitDefaults();
}
CAppPoolProps::CAppPoolProps(
CMetaKey * pKey, LPCTSTR meta_path
)
: CMetaProperties(pKey, meta_path)
{
InitDefaults();
}
void
CAppPoolProps::ParseFields()
{
BEGIN_PARSE_META_RECORDS(m_dwNumEntries, m_pbMDData)
HANDLE_META_RECORD(MD_APPPOOL_FRIENDLY_NAME, m_strFriendlyName)
HANDLE_META_RECORD(MD_APPPOOL_PERIODIC_RESTART_TIME, m_dwPeriodicRestartTime)
HANDLE_META_RECORD(MD_APPPOOL_PERIODIC_RESTART_SCHEDULE, m_RestartSchedule)
HANDLE_META_RECORD(MD_APPPOOL_PERIODIC_RESTART_REQUEST_COUNT, m_dwRestartRequestCount)
HANDLE_META_RECORD(MD_APPPOOL_PERIODIC_RESTART_MEMORY, m_dwPeriodicRestartMemory)
HANDLE_META_RECORD(MD_APPPOOL_IDLE_TIMEOUT, m_dwIdleTimeout)
HANDLE_META_RECORD(MD_APPPOOL_UL_APPPOOL_QUEUE_LENGTH, m_dwQueueSize)
HANDLE_META_RECORD(MD_CPU_RESET_INTERVAL, m_dwRefreshTime)
HANDLE_META_RECORD(MD_APPPOOL_MAX_PROCESS_COUNT, m_dwMaxProcesses)
HANDLE_META_RECORD(MD_CPU_LIMIT, m_dwMaxCPU_Use)
HANDLE_META_RECORD(MD_CPU_ACTION, m_ActionIndex)
HANDLE_META_RECORD(MD_APPPOOL_PINGING_ENABLED, m_fDoEnablePing)
HANDLE_META_RECORD(MD_APPPOOL_PING_INTERVAL, m_dwPingInterval)
HANDLE_META_RECORD(MD_APPPOOL_RAPID_FAIL_PROTECTION_ENABLED, m_fDoEnableRapidFail)
HANDLE_META_RECORD(MD_RAPID_FAIL_PROTECTION_MAX_CRASHES, m_dwCrashesCount)
HANDLE_META_RECORD(MD_RAPID_FAIL_PROTECTION_INTERVAL, m_dwCheckInterval)
HANDLE_META_RECORD(MD_APPPOOL_STARTUP_TIMELIMIT, m_dwStartupLimit)
HANDLE_META_RECORD(MD_APPPOOL_SHUTDOWN_TIMELIMIT, m_dwShutdownLimit)
HANDLE_META_RECORD(MD_APPPOOL_ORPHAN_PROCESSES_FOR_DEBUGGING, m_fDoEnableDebug)
HANDLE_META_RECORD(MD_APPPOOL_ORPHAN_ACTION, m_DebuggerFileName)
HANDLE_META_RECORD(MD_APPPOOL_IDENTITY_TYPE, m_dwIdentType)
HANDLE_META_RECORD(MD_WAM_USER_NAME, m_strUserName)
HANDLE_META_RECORD(MD_WAM_PWD, m_strUserPass)
END_PARSE_META_RECORDS
}
/* virtual */
HRESULT
CAppPoolProps::WriteDirtyProps()
/*++
Routine Description:
Write the dirty properties to the metabase
Arguments:
None
Return Value:
HRESULT
--*/
{
CError err;
BEGIN_META_WRITE()
META_WRITE(MD_APPPOOL_FRIENDLY_NAME, m_strFriendlyName)
META_WRITE(MD_APPPOOL_PERIODIC_RESTART_TIME, m_dwPeriodicRestartTime)
META_WRITE(MD_APPPOOL_PERIODIC_RESTART_SCHEDULE, m_RestartSchedule)
META_WRITE(MD_APPPOOL_PERIODIC_RESTART_REQUEST_COUNT, m_dwRestartRequestCount)
META_WRITE(MD_APPPOOL_PERIODIC_RESTART_MEMORY, m_dwPeriodicRestartMemory)
META_WRITE(MD_APPPOOL_IDLE_TIMEOUT, m_dwIdleTimeout)
META_WRITE(MD_APPPOOL_UL_APPPOOL_QUEUE_LENGTH, m_dwQueueSize)
META_WRITE(MD_CPU_RESET_INTERVAL, m_dwRefreshTime)
META_WRITE(MD_APPPOOL_MAX_PROCESS_COUNT, m_dwMaxProcesses)
META_WRITE(MD_CPU_LIMIT, m_dwMaxCPU_Use)
META_WRITE(MD_CPU_ACTION, m_ActionIndex)
META_WRITE(MD_APPPOOL_PINGING_ENABLED, m_fDoEnablePing)
META_WRITE(MD_APPPOOL_PING_INTERVAL, m_dwPingInterval)
META_WRITE(MD_APPPOOL_RAPID_FAIL_PROTECTION_ENABLED, m_fDoEnableRapidFail)
META_WRITE(MD_RAPID_FAIL_PROTECTION_MAX_CRASHES, m_dwCrashesCount)
META_WRITE(MD_RAPID_FAIL_PROTECTION_INTERVAL, m_dwCheckInterval)
META_WRITE(MD_APPPOOL_STARTUP_TIMELIMIT, m_dwStartupLimit)
META_WRITE(MD_APPPOOL_SHUTDOWN_TIMELIMIT, m_dwShutdownLimit)
META_WRITE(MD_APPPOOL_ORPHAN_PROCESSES_FOR_DEBUGGING, m_fDoEnableDebug)
META_WRITE(MD_APPPOOL_ORPHAN_ACTION, m_DebuggerFileName)
META_WRITE(MD_APPPOOL_IDENTITY_TYPE, m_dwIdentType)
META_WRITE(MD_WAM_USER_NAME, m_strUserName)
META_WRITE(MD_WAM_PWD, m_strUserPass)
END_META_WRITE(err);
return err;
}
void
CAppPoolProps::InitDefaults()
{
m_dwPeriodicRestartTime = PERIODIC_RESTART_TIME_DEF;
m_dwRestartRequestCount = PERIODIC_RESTART_REQ_DEF;
m_dwPeriodicRestartMemory = 0; //???
m_dwIdleTimeout = IDLE_TIMEOUT_DEF;
m_dwQueueSize = QUEUE_SIZE_DEF;
m_dwMaxCPU_Use = CPU_USE_DEF;
m_dwRefreshTime = CPU_RESET_TIME_DEF;
m_ActionIndex = ACTION_INDEX_DEF;
m_dwMaxProcesses = MAX_PROCESSES_DEF;
m_fDoEnablePing = TRUE;
m_dwPingInterval = PING_INTERVAL_DEF;
m_fDoEnableRapidFail = TRUE;
m_dwCrashesCount = CRASHES_COUNT_DEF;
m_dwCheckInterval = CHECK_INTERVAL_DEF;
m_dwStartupLimit = STARTUP_LIMIT_DEF;
m_dwShutdownLimit = SHUTDOWN_LIMIT_DEF;
m_fDoEnableDebug = FALSE;
m_dwIdentType = IDENT_TYPE_LOCALSYSTEM;
}
void
CAppPoolProps::InitFromModel(CAppPoolProps& model)
{
m_dwPeriodicRestartTime = model.m_dwPeriodicRestartTime;
m_dwRestartRequestCount = model.m_dwRestartRequestCount;
m_dwPeriodicRestartMemory = model.m_dwPeriodicRestartMemory;
m_RestartSchedule = model.m_RestartSchedule;
m_dwIdleTimeout = model.m_dwIdleTimeout;
m_dwQueueSize = model.m_dwQueueSize;
m_dwMaxCPU_Use = model.m_dwMaxCPU_Use;
m_dwRefreshTime = model.m_dwRefreshTime;
m_ActionIndex = model.m_ActionIndex;
m_dwMaxProcesses = model.m_dwMaxProcesses;
m_fDoEnablePing = model.m_fDoEnablePing;
m_dwPingInterval = model.m_dwPingInterval;
m_fDoEnableRapidFail = model.m_fDoEnableRapidFail;
m_dwCrashesCount = model.m_dwCrashesCount;
m_dwCheckInterval = model.m_dwCheckInterval;
m_dwStartupLimit = model.m_dwStartupLimit;
m_dwShutdownLimit = model.m_dwShutdownLimit;
m_fDoEnableDebug = model.m_fDoEnableDebug;
m_DebuggerFileName = model.m_DebuggerFileName;
m_dwIdentType = model.m_dwIdentType;
m_strUserName = model.m_strUserName;
m_strUserPass = model.m_strUserPass;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC(CAppPoolSheet, CInetPropertySheet)
CAppPoolSheet::CAppPoolSheet(
CComAuthInfo * pAuthInfo,
LPCTSTR lpszMetaPath,
CWnd * pParentWnd,
LPARAM lParam,
LONG_PTR handle,
UINT iSelectPage
)
: CInetPropertySheet(
pAuthInfo, lpszMetaPath, pParentWnd, lParam, handle, iSelectPage),
m_pprops(NULL)
{
CString last;
CMetabasePath::GetLastNodeName(lpszMetaPath, last);
SetIsMasterInstance(last.CompareNoCase(SZ_MBN_APP_POOLS) == 0);
}
CAppPoolSheet::~CAppPoolSheet()
{
FreeConfigurationParameters();
}
HRESULT
CAppPoolSheet::LoadConfigurationParameters()
{
//
// Load base properties
//
CError err;
if (m_pprops == NULL)
{
//
// First call -- load values
//
m_pprops = new CAppPoolProps(QueryAuthInfo(), QueryMetaPath());
if (!m_pprops)
{
TRACEEOLID("LoadConfigurationParameters: OOM");
err = ERROR_NOT_ENOUGH_MEMORY;
return err;
}
err = m_pprops->LoadData();
if (IsMasterInstance())
{
CAppPoolsContainer * pObject = (CAppPoolsContainer *)GetParameter();
m_pprops->m_strFriendlyName = pObject->QueryDisplayName();
}
}
return err;
}
void
CAppPoolSheet::FreeConfigurationParameters()
{
CInetPropertySheet::FreeConfigurationParameters();
delete m_pprops;
}
BEGIN_MESSAGE_MAP(CAppPoolSheet, CInetPropertySheet)
//{{AFX_MSG_MAP(CAppPoolSheet)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CAppPoolGeneral, CInetPropertyPage)
CAppPoolGeneral::CAppPoolGeneral(CInetPropertySheet * pSheet)
: CInetPropertyPage(CAppPoolGeneral::IDD, pSheet)
{
}
CAppPoolGeneral::~CAppPoolGeneral()
{
}
/* virtual */
HRESULT
CAppPoolGeneral::FetchLoadedValues()
{
CError err;
BEGIN_META_INST_READ(CAppPoolSheet)
FETCH_INST_DATA_FROM_SHEET(m_strFriendlyName);
FETCH_INST_DATA_FROM_SHEET(m_strTemplateName);
END_META_INST_READ(err)
if (IsMasterInstance())
{
m_fUseTemplate = FALSE;
}
else
{
m_fUseTemplate = !m_strTemplateName.IsEmpty();
}
return S_OK;
}
/* virtual */
HRESULT
CAppPoolGeneral::SaveInfo()
{
ASSERT(IsDirty());
CError err;
if (m_fUseTemplate)
{
m_Templates.GetLBText(m_TemplateIndex, m_strTemplateName);
}
else
{
m_strTemplateName.Empty();
}
BEGIN_META_INST_WRITE(CAppPoolSheet)
STORE_INST_DATA_ON_SHEET(m_strTemplateName)
if (!IsMasterInstance())
{
STORE_INST_DATA_ON_SHEET(m_strFriendlyName)
}
END_META_INST_WRITE(err)
return err;
}
void
CAppPoolGeneral::DoDataExchange(CDataExchange * pDX)
{
CInetPropertyPage::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CAppPoolGeneral)
DDX_Control(pDX, IDC_FRIENDLY_NAME, m_edit_FriendlyName);
DDX_Text(pDX, IDC_FRIENDLY_NAME, m_strFriendlyName);
DDX_Control(pDX, IDC_USE_TEMPLATE, m_btn_UseTemplate);
DDX_Control(pDX, IDC_USE_CUSTOM, m_btn_UseCustom);
DDX_Control(pDX, IDC_TEMPLATE_LIST, m_Templates);
DDX_CBIndex(pDX, IDC_TEMPLATE_LIST, m_TemplateIndex);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CAppPoolGeneral, CInetPropertyPage)
//{{AFX_MSG_MAP(CAppPoolGeneral)
ON_BN_CLICKED(IDC_USE_TEMPLATE, OnUseTemplate)
ON_BN_CLICKED(IDC_USE_CUSTOM, OnUseCustom)
ON_EN_CHANGE(IDC_FRIENDLY_NAME, OnItemChanged)
ON_CBN_SELCHANGE(IDC_TEMPLATE_LIST, OnItemChanged)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
BOOL
CAppPoolGeneral::OnInitDialog()
{
CInetPropertyPage::OnInitDialog();
m_edit_FriendlyName.EnableWindow(!IsMasterInstance());
m_btn_UseTemplate.EnableWindow(!IsMasterInstance());
m_Templates.EnableWindow(m_fUseTemplate);
if (m_fUseTemplate)
{
int idx = m_Templates.FindStringExact(-1, m_strTemplateName);
if (CB_ERR != idx)
{
m_Templates.SetCurSel(idx);
}
else
{
ASSERT(FALSE); // TODO: should we switch off the flag?
}
}
m_btn_UseTemplate.SetCheck(m_fUseTemplate);
m_btn_UseCustom.SetCheck(!m_fUseTemplate);
return TRUE;
}
void
CAppPoolGeneral::OnUseTemplate()
{
m_fUseTemplate = m_btn_UseTemplate.GetCheck();
m_btn_UseTemplate.SetCheck(m_fUseTemplate);
m_btn_UseCustom.SetCheck(!m_fUseTemplate);
SetModified(TRUE);
}
void
CAppPoolGeneral::OnUseCustom()
{
m_fUseTemplate = m_btn_UseCustom.GetCheck();
m_btn_UseTemplate.SetCheck(m_fUseTemplate);
m_btn_UseCustom.SetCheck(m_fUseTemplate);
SetModified(TRUE);
}
void
CAppPoolGeneral::OnItemChanged()
{
SetModified(TRUE);
}
//////////////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CAppPoolRecycle, CInetPropertyPage)
CAppPoolRecycle::CAppPoolRecycle(CInetPropertySheet * pSheet)
: CInetPropertyPage(CAppPoolRecycle::IDD, pSheet),
m_fDoRestartOnTime(FALSE),
m_fDoRestartOnCount(FALSE),
m_fDoRestartOnSchedule(FALSE),
m_fDoRestartOnMemory(FALSE)
{
m_dwPeriodicRestartMemory = 0;
}
CAppPoolRecycle::~CAppPoolRecycle()
{
}
/* virtual */
HRESULT
CAppPoolRecycle::FetchLoadedValues()
{
CError err;
BEGIN_META_INST_READ(CAppPoolSheet)
FETCH_INST_DATA_FROM_SHEET(m_dwPeriodicRestartTime);
FETCH_INST_DATA_FROM_SHEET(m_dwRestartRequestCount);
FETCH_INST_DATA_FROM_SHEET(m_RestartSchedule);
FETCH_INST_DATA_FROM_SHEET(m_dwPeriodicRestartMemory);
END_META_INST_READ(err)
m_fDoRestartOnTime = m_dwPeriodicRestartTime != 0;
if (!m_fDoRestartOnTime)
{
m_dwPeriodicRestartTime = PERIODIC_RESTART_TIME_DEF;
}
m_fDoRestartOnCount = m_dwRestartRequestCount != 0;
if (!m_fDoRestartOnCount)
{
m_dwRestartRequestCount = PERIODIC_RESTART_REQ_DEF;
}
m_fDoRestartOnSchedule = m_RestartSchedule.GetCount() > 0;
m_fDoRestartOnMemory = m_dwPeriodicRestartMemory != 0;
if (!m_fDoRestartOnMemory)
{
m_dwPeriodicRestartMemoryDisplay = MEMORY_DEF;
}
else
{
m_dwPeriodicRestartMemoryDisplay = m_dwPeriodicRestartMemory / 1024;
}
return err;
}
/* virtual */
HRESULT
CAppPoolRecycle::SaveInfo()
{
ASSERT(IsDirty());
CError err;
int count = m_lst_Schedule.GetCount();
TCHAR buf[32];
SYSTEMTIME tm;
::GetSystemTime(&tm);
m_RestartSchedule.RemoveAll();
if (m_fDoRestartOnSchedule)
{
for (int i = 0; i < count; i++)
{
DWORD data = (DWORD)m_lst_Schedule.GetItemData(i);
tm.wMinute = LOWORD(data);
tm.wHour = HIWORD(data);
::GetTimeFormat(LOCALE_SYSTEM_DEFAULT,
TIME_NOSECONDS | TIME_FORCE24HOURFORMAT,
&tm, _T("hh':'mm"), buf, 32);
m_RestartSchedule.AddTail(buf);
}
}
DWORD d;
CStringListEx list;
BEGIN_META_INST_WRITE(CAppPoolSheet)
d = m_dwPeriodicRestartTime;
if (!m_fDoRestartOnTime)
m_dwPeriodicRestartTime = 0;
STORE_INST_DATA_ON_SHEET(m_dwPeriodicRestartTime)
m_dwPeriodicRestartTime = d;
d = m_dwRestartRequestCount;
if (!m_fDoRestartOnCount)
m_dwRestartRequestCount = 0;
STORE_INST_DATA_ON_SHEET(m_dwRestartRequestCount)
m_dwRestartRequestCount = d;
list = m_RestartSchedule;
if (!m_fDoRestartOnSchedule)
m_RestartSchedule.RemoveAll();
STORE_INST_DATA_ON_SHEET(m_RestartSchedule)
m_RestartSchedule = list;
m_dwPeriodicRestartMemory = m_dwPeriodicRestartMemoryDisplay * 1024;
if (!m_fDoRestartOnMemory)
m_dwPeriodicRestartMemory = 0;
STORE_INST_DATA_ON_SHEET(m_dwPeriodicRestartMemory)
END_META_INST_WRITE(err)
return err;
}
void
CAppPoolRecycle::DoDataExchange(CDataExchange * pDX)
{
CInetPropertyPage::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CAppPoolRecycle)
DDX_Check(pDX, IDC_RECYCLE_TIMESPAN, m_fDoRestartOnTime);
DDX_Control(pDX, IDC_RECYCLE_TIMESPAN, m_bnt_DoRestartOnTime);
DDX_Text(pDX, IDC_TIMESPAN, m_dwPeriodicRestartTime);
DDV_MinMaxInt(pDX, m_dwPeriodicRestartTime, TIMESPAN_MIN, TIMESPAN_MAX);
DDX_Control(pDX, IDC_TIMESPAN, m_Timespan);
DDX_Control(pDX, IDC_TIMESPAN_SPIN, m_TimespanSpin);
DDX_Check(pDX, IDC_RECYCLE_REQUESTS, m_fDoRestartOnCount);
DDX_Control(pDX, IDC_RECYCLE_REQUESTS, m_btn_DoRestartOnCount);
DDX_Text(pDX, IDC_REQUEST_LIMIT, m_dwRestartRequestCount);
DDV_MinMaxInt(pDX, m_dwRestartRequestCount, REQUESTS_MIN, REQUESTS_MAX);
DDX_Control(pDX, IDC_REQUEST_LIMIT, m_Requests);
DDX_Control(pDX, IDC_REQUESTS_SPIN, m_RequestsSpin);
DDX_Check(pDX, IDC_RECYCLE_TIMER, m_fDoRestartOnSchedule);
DDX_Control(pDX, IDC_RECYCLE_TIMER, m_btn_DoRestartOnSchedule);
DDX_Control(pDX, IDC_TIMES_LIST, m_lst_Schedule);
DDX_Control(pDX, IDC_ADD_TIME, m_btn_Add);
DDX_Control(pDX, IDC_DELETE_TIME, m_btn_Remove);
DDX_Control(pDX, IDC_CHANGE_TIME, m_btn_Edit);
DDX_Check(pDX, IDC_RECYCLE_MEMORY, m_fDoRestartOnMemory);
DDX_Control(pDX, IDC_RECYCLE_MEMORY, m_btn_DoRestartOnMemory);
DDX_Text(pDX, IDC_MEMORY_LIMIT, m_dwPeriodicRestartMemoryDisplay);
DDV_MinMaxInt(pDX, m_dwPeriodicRestartMemoryDisplay, MEMORY_MIN, MEMORY_MAX);
DDX_Control(pDX, IDC_MEMORY_LIMIT, m_MemoryLimit);
DDX_Control(pDX, IDC_MEMORY_SPIN, m_MemoryLimitSpin);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CAppPoolRecycle, CInetPropertyPage)
//{{AFX_MSG_MAP(CAppPoolRecycle)
ON_WM_COMPAREITEM()
ON_WM_MEASUREITEM()
ON_WM_DRAWITEM()
ON_BN_CLICKED(IDC_RECYCLE_TIMESPAN, OnDoRestartOnTime)
ON_BN_CLICKED(IDC_RECYCLE_REQUESTS, OnDoRestartOnCount)
ON_BN_CLICKED(IDC_RECYCLE_TIMER, OnDoRestartOnSchedule)
ON_BN_CLICKED(IDC_RECYCLE_MEMORY, OnDoRestartOnMemory)
ON_BN_CLICKED(IDC_ADD_TIME, OnAddTime)
ON_BN_CLICKED(IDC_DELETE_TIME, OnDeleteTime)
ON_BN_CLICKED(IDC_CHANGE_TIME, OnChangeTime)
ON_EN_CHANGE(IDC_TIMESPAN, OnItemChanged)
ON_EN_CHANGE(IDC_REQUEST_LIMIT, OnItemChanged)
ON_EN_CHANGE(IDC_MEMORY_LIMIT, OnItemChanged)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
BOOL
CAppPoolRecycle::OnInitDialog()
{
UDACCEL toAcc[3] = {{1, 1}, {3, 5}, {6, 10}};
CInetPropertyPage::OnInitDialog();
m_Timespan.EnableWindow(m_fDoRestartOnTime);
m_TimespanSpin.EnableWindow(m_fDoRestartOnTime);
m_TimespanSpin.SetRange32(TIMESPAN_MIN,TIMESPAN_MAX);
m_TimespanSpin.SetPos(m_dwPeriodicRestartTime);
m_TimespanSpin.SetAccel(3, toAcc);
// SETUP_EDIT_SPIN(m_fDoRestartOnTime, m_Timespan, m_TimespanSpin,
// TIMESPAN_MIN, TIMESPAN_MAX, m_dwPeriodicRestartTime);
SETUP_EDIT_SPIN(m_fDoRestartOnCount, m_Requests, m_RequestsSpin,
REQUESTS_MIN, REQUESTS_MAX, m_dwRestartRequestCount);
SETUP_EDIT_SPIN(m_fDoRestartOnMemory, m_MemoryLimit, m_MemoryLimitSpin,
MEMORY_MIN, MEMORY_MAX, m_dwPeriodicRestartMemoryDisplay);
POSITION pos = m_RestartSchedule.GetHeadPosition();
while (pos != NULL)
{
CString& str = m_RestartSchedule.GetNext(pos);
int n = str.Find(_T(':'));
int len = str.GetLength();
WORD h = (WORD)StrToInt(str.Left(n));
WORD m = (WORD)StrToInt(str.Right(len - n - 1));
m_lst_Schedule.AddString((LPCTSTR)UIntToPtr(MAKELONG(m, h)));
}
m_lst_Schedule.SetCurSel(0);
SetControlsState();
return TRUE;
}
void
CAppPoolRecycle::SetControlsState()
{
m_Timespan.EnableWindow(m_fDoRestartOnTime);
m_TimespanSpin.EnableWindow(m_fDoRestartOnTime);
m_Requests.EnableWindow(m_fDoRestartOnCount);
m_RequestsSpin.EnableWindow(m_fDoRestartOnCount);
m_MemoryLimit.EnableWindow(m_fDoRestartOnMemory);
m_MemoryLimitSpin.EnableWindow(m_fDoRestartOnMemory);
m_lst_Schedule.EnableWindow(m_fDoRestartOnSchedule);
m_btn_Add.EnableWindow(m_fDoRestartOnSchedule);
int idx = m_lst_Schedule.GetCurSel();
m_btn_Remove.EnableWindow(m_fDoRestartOnSchedule && idx != LB_ERR);
m_btn_Edit.EnableWindow(m_fDoRestartOnSchedule && idx != LB_ERR);
}
void
CAppPoolRecycle::OnItemChanged()
{
SetModified(TRUE);
}
int
CAppPoolRecycle::OnCompareItem(UINT nID, LPCOMPAREITEMSTRUCT cmpi)
{
if (nID == IDC_TIMES_LIST)
{
ASSERT(cmpi->CtlType == ODT_LISTBOX);
if (cmpi->itemData1 > cmpi->itemData2)
return 1;
else if (cmpi->itemData1 == cmpi->itemData2)
return 0;
else
return -1;
}
ASSERT(FALSE);
return 0;
}
void
CAppPoolRecycle::OnMeasureItem(UINT nID, LPMEASUREITEMSTRUCT mi)
{
if (nID == IDC_TIMES_LIST)
{
HWND hwnd = ::GetDlgItem(m_hWnd, IDC_TIMES_LIST);
HDC hdc = ::GetDC(hwnd);
HFONT hFont = (HFONT)SendDlgItemMessage(IDC_TIMES_LIST, WM_GETFONT, 0, 0);
HFONT hf = (HFONT)::SelectObject(hdc, hFont);
TEXTMETRIC tm;
::GetTextMetrics(hdc, &tm);
::SelectObject(hdc, hf);
::ReleaseDC(hwnd, hdc);
RECT rc;
::GetClientRect(hwnd, &rc);
mi->itemHeight = tm.tmHeight;
mi->itemWidth = rc.right - rc.left;
}
}
void
CAppPoolRecycle::OnDrawItem(UINT nID, LPDRAWITEMSTRUCT di)
{
if (nID == IDC_TIMES_LIST && di->itemID != -1)
{
SYSTEMTIME tm;
::GetSystemTime(&tm);
tm.wMinute = LOWORD(di->itemData);
tm.wHour = HIWORD(di->itemData);
TCHAR buf[32];
TCHAR fmt[] = _T("HH:mm");
::GetTimeFormat(NULL /*LOCALE_SYSTEM_DEFAULT*/, TIME_NOSECONDS, &tm, fmt, buf, 32);
HBRUSH hBrush;
COLORREF prevText;
COLORREF prevBk;
switch (di->itemAction)
{
case ODA_SELECT:
case ODA_DRAWENTIRE:
if (di->itemState & ODS_SELECTED)
{
hBrush = ::CreateSolidBrush(GetSysColor(COLOR_HIGHLIGHT));
prevText = ::SetTextColor(di->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
prevBk = ::SetBkColor(di->hDC, GetSysColor(COLOR_HIGHLIGHT));
}
else
{
hBrush = CreateSolidBrush(GetSysColor(COLOR_WINDOW));
prevText = ::SetTextColor(di->hDC, GetSysColor(COLOR_WINDOWTEXT));
prevBk = ::SetBkColor(di->hDC, GetSysColor(COLOR_WINDOW));
}
::FillRect(di->hDC, &di->rcItem, hBrush);
::DrawText(di->hDC, buf, -1, &di->rcItem, DT_LEFT | DT_VCENTER | DT_EXTERNALLEADING);
::SetTextColor(di->hDC, prevText);
::SetTextColor(di->hDC, prevBk);
::DeleteObject(hBrush);
break;
case ODA_FOCUS:
break;
}
}
}
void
CAppPoolRecycle::OnDoRestartOnTime()
{
m_fDoRestartOnTime = !m_fDoRestartOnTime;
SetControlsState();
SetModified(TRUE);
}
void
CAppPoolRecycle::OnDoRestartOnCount()
{
m_fDoRestartOnCount = !m_fDoRestartOnCount;
SetControlsState();
SetModified(TRUE);
}
void
CAppPoolRecycle::OnDoRestartOnSchedule()
{
m_fDoRestartOnSchedule = !m_fDoRestartOnSchedule;
SetControlsState();
SetModified(TRUE);
}
void
CAppPoolRecycle::OnDoRestartOnMemory()
{
m_fDoRestartOnMemory = !m_fDoRestartOnMemory;
SetControlsState();
SetModified(TRUE);
}
class CTimePickerDlg : public CDialog
{
DECLARE_DYNCREATE(CTimePickerDlg)
public:
CTimePickerDlg()
: CDialog(CTimePickerDlg::IDD),
m_TopLeft(0, 0)
{
}
~CTimePickerDlg()
{
}
void SetTime(CTime& tm)
{
m_time = tm;
}
CTime& GetTime()
{
return m_time;
}
void SetPos(const CPoint& pt)
{
m_TopLeft = pt;
}
//
// Dialog Data
//
protected:
//{{AFX_DATA(CTimePickerDlg)
enum {IDD = IDD_TIME_PICKER};
CDateTimeCtrl m_Timer;
CTime m_time;
//}}AFX_DATA
CPoint m_TopLeft;
//{{AFX_MSG(CTimePickerDlg)
BOOL OnInitDialog();
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
protected:
//{{AFX_VIRTUAL(CTimePickerDlg)
virtual void DoDataExchange(CDataExchange * pDX);
//}}AFX_VIRTUAL
};
void
CTimePickerDlg::DoDataExchange(CDataExchange * pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CAppPoolRecycle)
DDX_DateTimeCtrl(pDX, IDC_TIME_PICKER, m_time);
DDX_Control(pDX, IDC_TIME_PICKER, m_Timer);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CTimePickerDlg, CDialog)
//{{AFX_MSG_MAP(CTimePickerDlg)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
IMPLEMENT_DYNCREATE(CTimePickerDlg, CDialog)
BOOL
CTimePickerDlg::OnInitDialog()
{
CDialog::OnInitDialog();
m_Timer.SetFormat(_T("HH:mm"));
m_Timer.SetTime(&m_time);
SetWindowPos(NULL, m_TopLeft.x, m_TopLeft.y, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
return TRUE;
}
void
CAppPoolRecycle::OnAddTime()
{
CTimePickerDlg dlg;
RECT rc;
m_btn_Add.GetWindowRect(&rc);
dlg.SetPos(CPoint(rc.left, rc.bottom));
dlg.SetTime(CTime::GetCurrentTime());
if (dlg.DoModal() == IDOK)
{
int idx;
CTime tm = dlg.GetTime();
LONG_PTR l = (LONG_PTR)MAKELONG(tm.GetMinute(), tm.GetHour());
if ((idx = m_lst_Schedule.FindString(-1, (LPCTSTR)l)) == LB_ERR)
{
idx = m_lst_Schedule.AddString((LPCTSTR)l);
m_lst_Schedule.SetCurSel(idx);
m_btn_Edit.EnableWindow(idx != LB_ERR);
m_btn_Remove.EnableWindow(idx != LB_ERR);
}
else
m_lst_Schedule.SetCurSel(idx);
SetModified(TRUE);
}
}
void
CAppPoolRecycle::OnChangeTime()
{
CTimePickerDlg dlg;
RECT rc;
m_btn_Edit.GetWindowRect(&rc);
dlg.SetPos(CPoint(rc.left, rc.bottom));
int idx = m_lst_Schedule.GetCurSel();
LONG l = (LONG)m_lst_Schedule.GetItemData(idx);
// Looks like we have to init the struct properly
SYSTEMTIME tm;
::GetSystemTime(&tm);
tm.wMinute = LOWORD(l);
tm.wHour = HIWORD(l);
tm.wSecond = 0;
dlg.SetTime(CTime(tm));
if (dlg.DoModal() == IDOK)
{
CTime t = dlg.GetTime();
LONG_PTR ll = (LONG_PTR)MAKELONG(t.GetMinute(), t.GetHour());
m_lst_Schedule.SetItemData(idx, ll);
m_lst_Schedule.GetItemRect(idx, &rc);
m_lst_Schedule.InvalidateRect(&rc, TRUE);
SetModified(TRUE);
}
}
void
CAppPoolRecycle::OnDeleteTime()
{
int idx = m_lst_Schedule.GetCurSel();
int count;
if (idx != LB_ERR)
{
m_lst_Schedule.DeleteString(idx);
SetModified(TRUE);
if ((count = m_lst_Schedule.GetCount()) == 0)
{
m_btn_Remove.EnableWindow(FALSE);
m_btn_Edit.EnableWindow(FALSE);
}
else
{
m_lst_Schedule.SetCurSel(idx == count ? --idx : idx);
}
}
}
//////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CAppPoolPerf, CInetPropertyPage)
CAppPoolPerf::CAppPoolPerf(CInetPropertySheet * pSheet)
: CInetPropertyPage(CAppPoolPerf::IDD, pSheet),
m_fDoIdleShutdown(FALSE),
m_dwIdleTimeout(IDLE_TIMEOUT_DEF),
m_fDoLimitQueue(FALSE),
m_dwQueueSize(QUEUE_SIZE_DEF),
m_fDoEnableCPUAccount(FALSE),
m_dwMaxCPU_Use(CPU_USE_DEF),
m_dwRefreshTime(CPU_RESET_TIME_DEF),
m_ActionIndex(ACTION_INDEX_DEF),
m_dwMaxProcesses(MAX_PROCESSES_DEF)
{
}
CAppPoolPerf::~CAppPoolPerf()
{
}
/* virtual */
HRESULT
CAppPoolPerf::FetchLoadedValues()
{
CError err;
BEGIN_META_INST_READ(CAppPoolSheet)
FETCH_INST_DATA_FROM_SHEET(m_dwIdleTimeout);
FETCH_INST_DATA_FROM_SHEET(m_dwQueueSize);
FETCH_INST_DATA_FROM_SHEET(m_dwMaxCPU_Use);
FETCH_INST_DATA_FROM_SHEET(m_dwRefreshTime);
FETCH_INST_DATA_FROM_SHEET(m_dwMaxProcesses);
FETCH_INST_DATA_FROM_SHEET(m_ActionIndex);
END_META_INST_READ(err)
m_dwMaxCPU_UseVisual = m_dwMaxCPU_Use / 1000;
m_fDoIdleShutdown = m_dwIdleTimeout != 0;
if (!m_fDoIdleShutdown)
{
m_dwIdleTimeout = IDLE_TIMEOUT_DEF;
}
m_fDoLimitQueue = m_dwQueueSize != 0;
if (!m_fDoLimitQueue)
{
m_dwQueueSize = QUEUE_SIZE_DEF;
}
m_fDoEnableCPUAccount = m_dwRefreshTime > 0;
if (!m_fDoEnableCPUAccount)
{
m_dwMaxCPU_UseVisual = CPU_USE_DEF;
m_dwRefreshTime = CPU_RESET_TIME_DEF;
m_ActionIndex = ACTION_INDEX_DEF;
}
return err;
}
/* virtual */
HRESULT
CAppPoolPerf::SaveInfo()
{
ASSERT(IsDirty());
CError err;
m_dwMaxCPU_Use = m_dwMaxCPU_UseVisual * 1000;
BEGIN_META_INST_WRITE(CAppPoolSheet)
if (!m_fDoIdleShutdown)
m_dwIdleTimeout = 0;
if (!m_fDoLimitQueue)
m_dwQueueSize = 0;
if (!m_fDoEnableCPUAccount)
{
m_dwRefreshTime = 0;
m_dwMaxCPU_Use = 0;
// m_ActionIndex = -1;
}
STORE_INST_DATA_ON_SHEET(m_dwQueueSize)
STORE_INST_DATA_ON_SHEET(m_dwIdleTimeout)
STORE_INST_DATA_ON_SHEET(m_dwRefreshTime)
STORE_INST_DATA_ON_SHEET(m_dwMaxCPU_Use)
STORE_INST_DATA_ON_SHEET(m_ActionIndex)
STORE_INST_DATA_ON_SHEET(m_dwMaxProcesses)
END_META_INST_WRITE(err)
return err;
}
void
CAppPoolPerf::DoDataExchange(CDataExchange * pDX)
{
CInetPropertyPage::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CAppPoolRecycle)
DDX_Check(pDX, IDC_PERF_IDLE_TIMEOUT, m_fDoIdleShutdown);
DDX_Control(pDX, IDC_PERF_IDLE_TIMEOUT, m_bnt_DoIdleShutdown);
DDX_Text(pDX, IDC_IDLETIME, m_dwIdleTimeout);
DDV_MinMaxInt(pDX, m_dwIdleTimeout, TIMEOUT_MIN, TIMEOUT_MAX);
DDX_Control(pDX, IDC_IDLETIME, m_IdleTimeout);
DDX_Control(pDX, IDC_IDLETIME_SPIN, m_IdleTimeoutSpin);
DDX_Check(pDX, IDC_LIMIT_QUEUE, m_fDoLimitQueue);
DDX_Control(pDX, IDC_LIMIT_QUEUE, m_btn_DoLimitQueue);
DDX_Text(pDX, IDC_QUEUESIZE, m_dwQueueSize);
DDV_MinMaxInt(pDX, m_dwQueueSize, QUEUESIZE_MIN, QUEUESIZE_MAX);
DDX_Control(pDX, IDC_QUEUESIZE, m_QueueSize);
DDX_Control(pDX, IDC_QUEUESIZE_SPIN, m_QueueSizeSpin);
DDX_Check(pDX, IDC_ENABLE_CPU_ACCOUNTING, m_fDoEnableCPUAccount);
DDX_Control(pDX, IDC_ENABLE_CPU_ACCOUNTING, m_btn_DoEnableCPUAccount);
DDX_Text(pDX, IDC_CPU_USE, m_dwMaxCPU_UseVisual);
DDV_MinMaxInt(pDX, m_dwMaxCPU_UseVisual, CPU_LIMIT_MIN, CPU_LIMIT_MAX);
DDX_Control(pDX, IDC_CPU_USE, m_MaxCPU_Use);
DDX_Control(pDX, IDC_CPU_USE_SPIN, m_MaxCPU_UseSpin);
DDX_Text(pDX, IDC_REFRESHTIME, m_dwRefreshTime);
DDV_MinMaxInt(pDX, m_dwRefreshTime, CPU_RESET_TIME_MIN, CPU_RESET_TIME_MAX);
DDX_Control(pDX, IDC_REFRESHTIME, m_RefreshTime);
DDX_Control(pDX, IDC_REFRESHTIME_SPIN, m_RefreshTimeSpin);
DDX_Control(pDX, IDC_EXCEED_ACTION, m_Action);
DDX_CBIndex(pDX, IDC_EXCEED_ACTION, m_ActionIndex);
DDX_Text(pDX, IDC_MAXPROCESSES, m_dwMaxProcesses);
DDV_MinMaxInt(pDX, m_dwMaxProcesses, MAXPROCESSES_MIN, MAXPROCESSES_MAX);
DDX_Control(pDX, IDC_MAXPROCESSES, m_MaxProcesses);
DDX_Control(pDX, IDC_MAXPROCESSES_SPIN, m_MaxProcessesSpin);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CAppPoolPerf, CInetPropertyPage)
//{{AFX_MSG_MAP(CAppPoolRecycle)
ON_BN_CLICKED(IDC_PERF_IDLE_TIMEOUT, OnDoIdleShutdown)
ON_BN_CLICKED(IDC_LIMIT_QUEUE, OnDoLimitQueue)
ON_BN_CLICKED(IDC_ENABLE_CPU_ACCOUNTING, OnDoEnableCPUAccount)
ON_EN_CHANGE(IDC_IDLETIME, OnItemChanged)
ON_EN_CHANGE(IDC_QUEUESIZE, OnItemChanged)
ON_EN_CHANGE(IDC_CPU_USE, OnItemChanged)
ON_EN_CHANGE(IDC_REFRESHTIME, OnItemChanged)
ON_EN_CHANGE(IDC_MAXPROCESSES, OnItemChanged)
ON_CBN_SELCHANGE(IDC_EXCEED_ACTION, OnItemChanged)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
BOOL
CAppPoolPerf::OnInitDialog()
{
UDACCEL toAcc[3] = {{1, 1}, {3, 5}, {6, 10}};
CInetPropertyPage::OnInitDialog();
SETUP_EDIT_SPIN(m_fDoIdleShutdown, m_IdleTimeout, m_IdleTimeoutSpin,
TIMEOUT_MIN, TIMEOUT_MAX, m_dwIdleTimeout);
SETUP_EDIT_SPIN(m_fDoLimitQueue, m_QueueSize, m_QueueSizeSpin,
QUEUESIZE_MIN, QUEUESIZE_MAX, m_dwQueueSize);
m_dwMaxCPU_UseVisual = m_dwMaxCPU_Use / 1000;
SETUP_EDIT_SPIN(m_fDoEnableCPUAccount, m_MaxCPU_Use, m_MaxCPU_UseSpin,
CPU_LIMIT_MIN, CPU_LIMIT_MAX, m_dwMaxCPU_UseVisual);
SETUP_EDIT_SPIN(m_fDoEnableCPUAccount, m_RefreshTime, m_RefreshTimeSpin,
REFRESH_TIME_MIN, REFRESH_TIME_MAX, m_dwRefreshTime);
SETUP_SPIN(m_MaxProcessesSpin,
MAXPROCESSES_MIN, MAXPROCESSES_MAX, m_dwMaxProcesses);
CString str;
str.LoadString(IDS_NO_ACTION);
m_Action.AddString(str);
// str.LoadString(IDS_THROTTLE_BACK);
// m_Action.AddString(str);
str.LoadString(IDS_TURN_ON_TRACING);
m_Action.AddString(str);
str.LoadString(IDS_SHUTDOWN);
m_Action.AddString(str);
if (m_ActionIndex < 0 || m_ActionIndex > 3)
m_ActionIndex = ACTION_INDEX_DEF;
m_Action.SetCurSel(m_ActionIndex);
SetControlsState();
return TRUE;
}
void
CAppPoolPerf::OnDoIdleShutdown()
{
m_fDoIdleShutdown = !m_fDoIdleShutdown;
SetControlsState();
SetModified(TRUE);
}
void
CAppPoolPerf::OnDoLimitQueue()
{
m_fDoLimitQueue = !m_fDoLimitQueue;
SetControlsState();
SetModified(TRUE);
}
void
CAppPoolPerf::OnDoEnableCPUAccount()
{
m_fDoEnableCPUAccount = !m_fDoEnableCPUAccount;
SetControlsState();
SetModified(TRUE);
}
void
CAppPoolPerf::OnItemChanged()
{
SetModified(TRUE);
}
void
CAppPoolPerf::SetControlsState()
{
m_bnt_DoIdleShutdown.SetCheck(m_fDoIdleShutdown);
m_IdleTimeout.EnableWindow(m_fDoIdleShutdown);
m_IdleTimeoutSpin.EnableWindow(m_fDoIdleShutdown);
m_btn_DoLimitQueue.SetCheck(m_fDoLimitQueue);
m_QueueSize.EnableWindow(m_fDoLimitQueue);
m_QueueSizeSpin.EnableWindow(m_fDoLimitQueue);
m_btn_DoEnableCPUAccount.SetCheck(m_fDoEnableCPUAccount);
m_MaxCPU_Use.EnableWindow(m_fDoEnableCPUAccount);
m_MaxCPU_UseSpin.EnableWindow(m_fDoEnableCPUAccount);
m_RefreshTime.EnableWindow(m_fDoEnableCPUAccount);
m_RefreshTimeSpin.EnableWindow(m_fDoEnableCPUAccount);
m_Action.EnableWindow(m_fDoEnableCPUAccount);
}
/////////////////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CAppPoolHealth, CInetPropertyPage)
CAppPoolHealth::CAppPoolHealth(CInetPropertySheet * pSheet)
: CInetPropertyPage(CAppPoolHealth::IDD, pSheet),
m_fDoEnablePing(FALSE),
m_dwPingInterval(PING_INTERVAL_DEF),
m_fDoEnableRapidFail(FALSE),
m_dwCrashesCount(CRASHES_COUNT_DEF),
m_dwCheckInterval(CHECK_INTERVAL_DEF),
m_dwStartupLimit(STARTUP_LIMIT_DEF),
m_dwShutdownLimit(SHUTDOWN_LIMIT_DEF)
{
}
CAppPoolHealth::~CAppPoolHealth()
{
}
/* virtual */
HRESULT
CAppPoolHealth::FetchLoadedValues()
{
CError err;
BEGIN_META_INST_READ(CAppPoolSheet)
FETCH_INST_DATA_FROM_SHEET(m_fDoEnablePing);
FETCH_INST_DATA_FROM_SHEET(m_dwPingInterval);
FETCH_INST_DATA_FROM_SHEET(m_fDoEnableRapidFail);
FETCH_INST_DATA_FROM_SHEET(m_dwCrashesCount);
FETCH_INST_DATA_FROM_SHEET(m_dwCheckInterval);
FETCH_INST_DATA_FROM_SHEET(m_dwStartupLimit);
FETCH_INST_DATA_FROM_SHEET(m_dwShutdownLimit);
END_META_INST_READ(err)
return err;
}
/* virtual */
HRESULT
CAppPoolHealth::SaveInfo()
{
ASSERT(IsDirty());
CError err;
BEGIN_META_INST_WRITE(CAppPoolSheet)
STORE_INST_DATA_ON_SHEET(m_fDoEnablePing);
STORE_INST_DATA_ON_SHEET(m_dwPingInterval);
STORE_INST_DATA_ON_SHEET(m_fDoEnableRapidFail);
STORE_INST_DATA_ON_SHEET(m_dwCrashesCount);
STORE_INST_DATA_ON_SHEET(m_dwCheckInterval);
STORE_INST_DATA_ON_SHEET(m_dwStartupLimit);
STORE_INST_DATA_ON_SHEET(m_dwShutdownLimit);
END_META_INST_WRITE(err)
return err;
}
void
CAppPoolHealth::DoDataExchange(CDataExchange * pDX)
{
CInetPropertyPage::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CAppPoolHealth)
DDX_Check(pDX, IDC_ENABLE_PING, m_fDoEnablePing);
DDX_Control(pDX, IDC_ENABLE_PING, m_bnt_DoEnablePing);
DDX_Text(pDX, IDC_PINGINTERVAL, m_dwPingInterval);
DDV_MinMaxInt(pDX, m_dwPingInterval, PING_INTERVAL_MIN, PING_INTERVAL_MAX);
DDX_Control(pDX, IDC_PINGINTERVAL, m_PingInterval);
DDX_Control(pDX, IDC_PINGINTERVAL_SPIN, m_PingIntervalSpin);
DDX_Check(pDX, IDC_ENABLE_RAPID_FAIL, m_fDoEnableRapidFail);
DDX_Control(pDX, IDC_ENABLE_RAPID_FAIL, m_btn_DoEnableRapidFail);
DDX_Text(pDX, IDC_CRASHES_COUNT, m_dwCrashesCount);
DDV_MinMaxInt(pDX, m_dwCrashesCount, CRASHES_COUNT_MIN, CRASHES_COUNT_MAX);
DDX_Control(pDX, IDC_CRASHES_COUNT, m_CrashesCount);
DDX_Control(pDX, IDC_CRASHES_COUNT_SPIN, m_CrashesCountSpin);
DDX_Text(pDX, IDC_CHECK_TIME, m_dwCheckInterval);
DDV_MinMaxInt(pDX, m_dwCheckInterval, CHECK_INTERVAL_MIN, CHECK_INTERVAL_MAX);
DDX_Control(pDX, IDC_CHECK_TIME, m_CheckInterval);
DDX_Control(pDX, IDC_CHECK_TIME_SPIN, m_CheckIntervalSpin);
DDX_Text(pDX, IDC_STARTUP_LIMIT, m_dwStartupLimit);
DDV_MinMaxInt(pDX, m_dwStartupLimit, STARTUP_LIMIT_MIN, STARTUP_LIMIT_MAX);
DDX_Control(pDX, IDC_STARTUP_LIMIT, m_StartupLimit);
DDX_Control(pDX, IDC_STARTUP_LIMIT_SPIN, m_StartupLimitSpin);
DDX_Text(pDX, IDC_SHUTDOWN_LIMIT, m_dwShutdownLimit);
DDV_MinMaxInt(pDX, m_dwShutdownLimit, SHUTDOWN_LIMIT_MIN, SHUTDOWN_LIMIT_MAX);
DDX_Control(pDX, IDC_SHUTDOWN_LIMIT, m_ShutdownLimit);
DDX_Control(pDX, IDC_SHUTDOWN_LIMIT_SPIN, m_ShutdownLimitSpin);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CAppPoolHealth, CInetPropertyPage)
//{{AFX_MSG_MAP(CAppPoolHealth)
ON_BN_CLICKED(IDC_ENABLE_PING, OnDoEnablePinging)
ON_BN_CLICKED(IDC_ENABLE_RAPID_FAIL, OnDoEnableRapidFail)
ON_EN_CHANGE(IDC_PINGINTERVAL, OnItemChanged)
ON_EN_CHANGE(IDC_CRASHES_COUNT, OnItemChanged)
ON_EN_CHANGE(IDC_CHECK_TIME, OnItemChanged)
ON_EN_CHANGE(IDC_STARTUP_LIMIT, OnItemChanged)
ON_EN_CHANGE(IDC_SHUTDOWN_LIMIT, OnItemChanged)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
BOOL
CAppPoolHealth::OnInitDialog()
{
UDACCEL toAcc[3] = {{1, 1}, {3, 5}, {6, 10}};
CInetPropertyPage::OnInitDialog();
SETUP_EDIT_SPIN(m_fDoEnablePing, m_PingInterval, m_PingIntervalSpin,
PING_INTERVAL_MIN, PING_INTERVAL_MAX, m_dwPingInterval);
SETUP_EDIT_SPIN(m_fDoEnableRapidFail, m_CrashesCount, m_CrashesCountSpin,
CRASHES_COUNT_MIN, CRASHES_COUNT_MAX, m_dwCrashesCount);
SETUP_EDIT_SPIN(m_fDoEnableRapidFail, m_CheckInterval, m_CheckIntervalSpin,
CHECK_INTERVAL_MIN, CHECK_INTERVAL_MAX, m_dwCheckInterval);
SETUP_SPIN(m_StartupLimitSpin,
STARTUP_LIMIT_MIN, STARTUP_LIMIT_MAX, m_dwStartupLimit);
SETUP_SPIN(m_ShutdownLimitSpin,
SHUTDOWN_LIMIT_MIN, SHUTDOWN_LIMIT_MAX, m_dwShutdownLimit);
return TRUE;
}
void
CAppPoolHealth::OnDoEnablePinging()
{
m_fDoEnablePing = !m_fDoEnablePing;
m_bnt_DoEnablePing.SetCheck(m_fDoEnablePing);
m_PingInterval.EnableWindow(m_fDoEnablePing);
m_PingIntervalSpin.EnableWindow(m_fDoEnablePing);
SetModified(TRUE);
}
void
CAppPoolHealth::OnDoEnableRapidFail()
{
m_fDoEnableRapidFail = !m_fDoEnableRapidFail;
m_btn_DoEnableRapidFail.SetCheck(m_fDoEnableRapidFail);
m_CrashesCount.EnableWindow(m_fDoEnableRapidFail);
m_CrashesCountSpin.EnableWindow(m_fDoEnableRapidFail);
m_CheckInterval.EnableWindow(m_fDoEnableRapidFail);
m_CheckIntervalSpin.EnableWindow(m_fDoEnableRapidFail);
SetModified(TRUE);
}
void
CAppPoolHealth::OnItemChanged()
{
SetModified(TRUE);
}
///////////////////////////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CAppPoolDebug, CInetPropertyPage)
CAppPoolDebug::CAppPoolDebug(CInetPropertySheet * pSheet)
: CInetPropertyPage(CAppPoolDebug::IDD, pSheet),
m_fDoEnableDebug(TRUE)
{
}
CAppPoolDebug::~CAppPoolDebug()
{
}
/* virtual */
HRESULT
CAppPoolDebug::FetchLoadedValues()
{
CError err;
BEGIN_META_INST_READ(CAppPoolSheet)
FETCH_INST_DATA_FROM_SHEET(m_fDoEnableDebug);
FETCH_INST_DATA_FROM_SHEET(m_DebuggerFileName);
END_META_INST_READ(err)
return err;
}
/* virtual */
HRESULT
CAppPoolDebug::SaveInfo()
{
ASSERT(IsDirty());
CError err;
BEGIN_META_INST_WRITE(CAppPoolSheet)
STORE_INST_DATA_ON_SHEET(m_fDoEnableDebug);
STORE_INST_DATA_ON_SHEET(m_DebuggerFileName);
END_META_INST_WRITE(err)
return err;
}
void
CAppPoolDebug::DoDataExchange(CDataExchange * pDX)
{
CInetPropertyPage::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CAppPoolHealth)
DDX_Check(pDX, IDC_ENABLE_DEBUG, m_fDoEnableDebug);
DDX_Control(pDX, IDC_ENABLE_DEBUG, m_bnt_DoEnableDebug);
DDX_Text(pDX, IDC_FILE_NAME, m_DebuggerFileName);
DDX_Control(pDX, IDC_FILE_NAME, m_FileName);
DDX_Control(pDX, IDC_BROWSE, m_Browse);
//}}AFX_DATA_MAP
if (pDX->m_bSaveAndValidate)
{
CError err;
if (!PathIsValid(m_DebuggerFileName))
{
::AfxMessageBox(IDS_ERR_BAD_PATH);
pDX->PrepareEditCtrl(IDC_FILE_NAME);
pDX->Fail();
}
else if (GetSheet()->IsLocal())
{
if (!PathFileExists(m_DebuggerFileName))
{
err = ERROR_FILE_NOT_FOUND;
}
}
}
}
BEGIN_MESSAGE_MAP(CAppPoolDebug, CInetPropertyPage)
//{{AFX_MSG_MAP(CAppPoolHealth)
ON_BN_CLICKED(IDC_ENABLE_DEBUG, OnDoEnableDebug)
ON_BN_CLICKED(IDC_BROWSE, OnBrowse)
ON_EN_CHANGE(IDC_FILE_NAME, OnItemChanged)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
BOOL
CAppPoolDebug::OnInitDialog()
{
CInetPropertyPage::OnInitDialog();
if (m_DebuggerFileName.IsEmpty())
m_fDoEnableDebug = FALSE;
SetControlState();
return TRUE;
}
void
CAppPoolDebug::SetControlState()
{
m_bnt_DoEnableDebug.SetCheck(m_fDoEnableDebug);
m_FileName.EnableWindow(m_fDoEnableDebug);
m_Browse.EnableWindow(m_fDoEnableDebug);
}
void
CAppPoolDebug::OnItemChanged()
{
SetModified(TRUE);
}
void
CAppPoolDebug::OnDoEnableDebug()
{
m_fDoEnableDebug = !m_fDoEnableDebug;
m_bnt_DoEnableDebug.SetCheck(m_fDoEnableDebug);
m_FileName.EnableWindow(m_fDoEnableDebug);
m_Browse.EnableWindow(m_fDoEnableDebug);
SetModified(TRUE);
}
void
CAppPoolDebug::OnBrowse()
{
CString mask((LPCTSTR)IDS_DEBUG_EXEC_MASK);
//
// CODEWORK: Derive a class from CFileDialog that allows
// the setting of the initial path
//
//CString strPath;
//m_edit_Executable.GetWindowText(strPath);
CFileDialog dlgBrowse(
TRUE,
NULL,
NULL,
OFN_HIDEREADONLY,
mask,
this
);
// Disable hook to get Windows 2000 style dialog
dlgBrowse.m_ofn.Flags &= ~(OFN_ENABLEHOOK);
dlgBrowse.m_ofn.Flags |= OFN_DONTADDTORECENT|OFN_FILEMUSTEXIST;
if (dlgBrowse.DoModal() == IDOK)
{
m_FileName.SetWindowText(dlgBrowse.GetPathName());
}
OnItemChanged();
}
/////////////////////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNCREATE(CAppPoolIdent, CInetPropertyPage)
CAppPoolIdent::CAppPoolIdent(CInetPropertySheet * pSheet)
: CInetPropertyPage(CAppPoolIdent::IDD, pSheet),
m_fPredefined(FALSE)
{
}
CAppPoolIdent::~CAppPoolIdent()
{
}
/* virtual */
HRESULT
CAppPoolIdent::FetchLoadedValues()
{
CError err;
BEGIN_META_INST_READ(CAppPoolSheet)
FETCH_INST_DATA_FROM_SHEET(m_dwIdentType);
FETCH_INST_DATA_FROM_SHEET(m_strUserName);
FETCH_INST_DATA_FROM_SHEET(m_strUserPass);
END_META_INST_READ(err)
m_fPredefined = m_dwIdentType != IDENT_TYPE_CONFIGURABLE;
switch (m_dwIdentType)
{
case IDENT_TYPE_LOCALSYSTEM:
m_PredefIndex = 0;
break;
case IDENT_TYPE_LOCALSERVICE:
m_PredefIndex = 1;
break;
case IDENT_TYPE_NETWORKSERVICE:
m_PredefIndex = 2;
break;
default:
m_PredefIndex = -1;
break;
}
return err;
}
/* virtual */
HRESULT
CAppPoolIdent::SaveInfo()
{
ASSERT(IsDirty());
CError err;
BEGIN_META_INST_WRITE(CAppPoolSheet)
if (m_fPredefined)
{
m_dwIdentType = m_PredefIndex;
}
else
{
m_dwIdentType = IDENT_TYPE_CONFIGURABLE;
STORE_INST_DATA_ON_SHEET(m_strUserName);
STORE_INST_DATA_ON_SHEET(m_strUserPass);
}
STORE_INST_DATA_ON_SHEET(m_dwIdentType);
END_META_INST_WRITE(err)
return err;
}
void
CAppPoolIdent::SetControlState()
{
m_bnt_Predefined.SetCheck(m_fPredefined);
m_bnt_Configurable.SetCheck(!m_fPredefined);
m_PredefList.EnableWindow(m_fPredefined);
m_UserName.EnableWindow(!m_fPredefined);
m_UserPass.EnableWindow(!m_fPredefined);
m_Browse.EnableWindow(!m_fPredefined);
}
void
CAppPoolIdent::DoDataExchange(CDataExchange * pDX)
{
CInetPropertyPage::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CAppPoolIdent)
DDX_Control(pDX, IDC_PREDEFINED, m_bnt_Predefined);
DDX_Control(pDX, IDC_CONFIGURABLE, m_bnt_Configurable);
DDX_CBIndex(pDX, IDC_SYSTEM_ACCOUNTS, m_PredefIndex);
DDX_Control(pDX, IDC_SYSTEM_ACCOUNTS, m_PredefList);
DDX_Text(pDX, IDC_USER_NAME, m_strUserName);
DDX_Control(pDX, IDC_USER_NAME, m_UserName);
DDX_Control(pDX, IDC_BROWSE, m_Browse);
DDX_Text(pDX, IDC_USER_PASS, m_strUserPass);
DDX_Control(pDX, IDC_USER_PASS, m_UserPass);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CAppPoolIdent, CInetPropertyPage)
//{{AFX_MSG_MAP(CAppPoolIdent)
ON_BN_CLICKED(IDC_PREDEFINED, OnPredefined)
ON_BN_CLICKED(IDC_CONFIGURABLE, OnPredefined)
ON_BN_CLICKED(IDC_BROWSE, OnBrowse)
ON_EN_CHANGE(IDC_USER_NAME, OnItemChanged)
ON_EN_CHANGE(IDC_USER_PASS, OnItemChanged)
ON_CBN_SELCHANGE(IDC_SYSTEM_ACCOUNTS, OnItemChanged)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
BOOL
CAppPoolIdent::OnInitDialog()
{
CInetPropertyPage::OnInitDialog();
CString buf;
buf.LoadString(IDS_LOCALSYSTEM);
m_PredefList.AddString(buf);
buf.LoadString(IDS_LOCALSERVICE);
m_PredefList.AddString(buf);
buf.LoadString(IDS_NETSERVICE);
m_PredefList.AddString(buf);
if (!m_fPredefined)
{
m_PredefIndex = 0;
}
m_PredefList.SetCurSel(m_PredefIndex);
SetControlState();
return TRUE;
}
void
CAppPoolIdent::OnPredefined()
{
m_fPredefined = !m_fPredefined;
SetControlState();
SetModified(TRUE);
}
void
CAppPoolIdent::OnBrowse()
{
// User browser like in other places
CString user;
if (GetIUsrAccount(user))
{
if (user.CompareNoCase(m_strUserName) != 0)
{
m_strUserPass.Empty();
}
m_strUserName = user;
UpdateData(FALSE);
}
}
void
CAppPoolIdent::OnItemChanged()
{
SetModified(TRUE);
}
Reference in New Issue View Git Blame Copy Permalink