archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
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.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 5c6fe3db62
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5c6fe3db62'
${ noResults }
windows-server-2003/inetsrv/iis/admin/snapin/app_pool_sheet.cpp

1841 lines
56 KiB
Raw 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_sheet.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 VMEMORY_MIN (int)1
#define VMEMORY_MAX (int)(2000000)
#define UMEMORY_MIN (int)1
#define UMEMORY_MAX (int)(2000000)
#define TIMEOUT_MIN (int)1
#define TIMEOUT_MAX (int)(4000000)
#define QUEUESIZE_MIN (int)0
#define QUEUESIZE_MAX (int)(65535)
#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)1
#define CPU_RESET_TIME_MAX (int)1440
#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 120
#define PERIODIC_RESTART_REQ_DEF 35000
#define VMEMORY_DEF 500 // In MB
#define UMEMORY_DEF 192 // In MB
#define IDLE_TIMEOUT_DEF 20
#define QUEUE_SIZE_DEF 2000
#define CPU_USE_DEF 100
#define CPU_RESET_TIME_DEF 5
#define ACTION_INDEX_DEF 0
#define MAX_PROCESSES_DEF 1
#define PING_INTERVAL_DEF 240
#define CRASHES_COUNT_DEF 5
#define CHECK_INTERVAL_DEF 5
#define STARTUP_LIMIT_DEF 90
#define SHUTDOWN_LIMIT_DEF 90
#define SLEEP_INTERVAL (500L)
//
// Maximum time to wait for service to attain desired state
//
#define MAX_SLEEP (180000) // For a service
#define MAX_SLEEP_POOL ( 30000) // For an instance
#define INIT_MEMBERS_DEF()\
m_dwPeriodicRestartTime(PERIODIC_RESTART_TIME_DEF),\
m_dwRestartRequestCount(PERIODIC_RESTART_REQ_DEF),\
m_dwPeriodicRestartVMemory(0),\
m_dwPeriodicRestartUMemory(0),\
m_dwIdleTimeout(IDLE_TIMEOUT_DEF),\
m_dwQueueSize(QUEUE_SIZE_DEF),\
m_dwMaxCPU_Use(CPU_USE_DEF * 1000),\
m_dwRefreshTime(0),\
m_ActionIndex(ACTION_INDEX_DEF),\
m_dwMaxProcesses(MAX_PROCESSES_DEF),\
m_dwPingInterval(PING_INTERVAL_DEF),\
m_dwCrashesCount(CRASHES_COUNT_DEF),\
m_dwCheckInterval(CHECK_INTERVAL_DEF),\
m_dwStartupLimit(STARTUP_LIMIT_DEF),\
m_dwShutdownLimit(SHUTDOWN_LIMIT_DEF),\
m_fDoEnablePing(TRUE),\
m_fDoEnableRapidFail(TRUE),\
m_dwIdentType(IDENT_TYPE_NETWORKSERVICE),\
m_dwState(MD_APPPOOL_STATE_STOPPED)
/////////////////////////////////////////////////////////////////////////////
// CAppPoolProps implementation
CAppPoolProps::CAppPoolProps(
CComAuthInfo * pAuthInfo, LPCTSTR meta_path, BOOL fInherit
)
: CMetaProperties(pAuthInfo, meta_path),
INIT_MEMBERS_DEF()
{
m_fInherit = fInherit;
}
CAppPoolProps::CAppPoolProps(
CMetaInterface * pInterface, LPCTSTR meta_path, BOOL fInherit
)
: CMetaProperties(pInterface, meta_path),
INIT_MEMBERS_DEF()
{
m_fInherit = fInherit;
}
CAppPoolProps::CAppPoolProps(
CMetaKey * pKey, LPCTSTR meta_path, BOOL fInherit
)
: CMetaProperties(pKey, meta_path),
INIT_MEMBERS_DEF()
{
m_fInherit = fInherit;
}
#define HANDLE_LOCAL_META_RECORD(id,v) \
case id: \
FetchMetaValue(pAllRecords, i, MP_V(v)); \
v.m_fDirty = (pAllRecords[i].dwMDAttributes & METADATA_ISINHERITED) == 0; \
break;
void
CAppPoolProps::ParseFields()
{
// m_AspMaxDiskTemplateCacheFiles = 0;
if (!m_fInherit)
{
// If we want only data defined on this node, we will set dirty flag for these props
BOOL f;
BEGIN_PARSE_META_RECORDS(m_dwNumEntries, m_pbMDData)
HANDLE_LOCAL_META_RECORD(MD_APPPOOL_PERIODIC_RESTART_TIME, m_dwPeriodicRestartTime)
HANDLE_LOCAL_META_RECORD(MD_APPPOOL_PERIODIC_RESTART_SCHEDULE, m_RestartSchedule)
HANDLE_LOCAL_META_RECORD(MD_APPPOOL_PERIODIC_RESTART_REQUEST_COUNT, m_dwRestartRequestCount)
HANDLE_LOCAL_META_RECORD(MD_APPPOOL_PERIODIC_RESTART_MEMORY, m_dwPeriodicRestartVMemory)
HANDLE_LOCAL_META_RECORD(MD_APPPOOL_PERIODIC_RESTART_PRIVATE_MEMORY, m_dwPeriodicRestartUMemory)
HANDLE_LOCAL_META_RECORD(MD_APPPOOL_IDLE_TIMEOUT, m_dwIdleTimeout)
HANDLE_LOCAL_META_RECORD(MD_APPPOOL_UL_APPPOOL_QUEUE_LENGTH, m_dwQueueSize)
HANDLE_LOCAL_META_RECORD(MD_CPU_RESET_INTERVAL, m_dwRefreshTime)
HANDLE_LOCAL_META_RECORD(MD_APPPOOL_MAX_PROCESS_COUNT, m_dwMaxProcesses)
HANDLE_LOCAL_META_RECORD(MD_CPU_LIMIT, m_dwMaxCPU_Use)
HANDLE_LOCAL_META_RECORD(MD_CPU_ACTION, m_ActionIndex)
HANDLE_LOCAL_META_RECORD(MD_APPPOOL_PINGING_ENABLED, m_fDoEnablePing)
HANDLE_LOCAL_META_RECORD(MD_APPPOOL_PING_INTERVAL, m_dwPingInterval)
HANDLE_LOCAL_META_RECORD(MD_APPPOOL_RAPID_FAIL_PROTECTION_ENABLED, m_fDoEnableRapidFail)
HANDLE_LOCAL_META_RECORD(MD_RAPID_FAIL_PROTECTION_MAX_CRASHES, m_dwCrashesCount)
HANDLE_LOCAL_META_RECORD(MD_RAPID_FAIL_PROTECTION_INTERVAL, m_dwCheckInterval)
HANDLE_LOCAL_META_RECORD(MD_APPPOOL_STARTUP_TIMELIMIT, m_dwStartupLimit)
HANDLE_LOCAL_META_RECORD(MD_APPPOOL_SHUTDOWN_TIMELIMIT, m_dwShutdownLimit)
HANDLE_LOCAL_META_RECORD(MD_APPPOOL_ORPHAN_PROCESSES_FOR_DEBUGGING, m_fDoEnableDebug)
HANDLE_LOCAL_META_RECORD(MD_APPPOOL_ORPHAN_ACTION_EXE, m_DebuggerFileName)
HANDLE_LOCAL_META_RECORD(MD_APPPOOL_ORPHAN_ACTION_PARAMS, m_DebuggerParams)
HANDLE_LOCAL_META_RECORD(MD_APPPOOL_IDENTITY_TYPE, m_dwIdentType)
HANDLE_LOCAL_META_RECORD(MD_WAM_USER_NAME, m_strUserName)
HANDLE_LOCAL_META_RECORD(MD_WAM_PWD, m_strUserPass)
HANDLE_LOCAL_META_RECORD(MD_APPPOOL_STATE, m_dwState)
HANDLE_LOCAL_META_RECORD(MD_WIN32_ERROR, m_dwWin32Error)
END_PARSE_META_RECORDS
}
else
{
BEGIN_PARSE_META_RECORDS(m_dwNumEntries, m_pbMDData)
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_dwPeriodicRestartVMemory)
HANDLE_META_RECORD(MD_APPPOOL_PERIODIC_RESTART_PRIVATE_MEMORY, m_dwPeriodicRestartUMemory)
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_EXE, m_DebuggerFileName)
HANDLE_META_RECORD(MD_APPPOOL_ORPHAN_ACTION_PARAMS, m_DebuggerParams)
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)
HANDLE_META_RECORD(MD_APPPOOL_STATE, m_dwState)
HANDLE_META_RECORD(MD_WIN32_ERROR, m_dwWin32Error)
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_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_dwPeriodicRestartVMemory)
META_WRITE(MD_APPPOOL_PERIODIC_RESTART_PRIVATE_MEMORY, m_dwPeriodicRestartUMemory)
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_EXE, m_DebuggerFileName)
META_WRITE(MD_APPPOOL_ORPHAN_ACTION_PARAMS, m_DebuggerParams)
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::InitFromModel(CAppPoolProps& model)
{
m_dwPeriodicRestartTime = model.m_dwPeriodicRestartTime;
m_dwRestartRequestCount = model.m_dwRestartRequestCount;
m_dwPeriodicRestartVMemory = model.m_dwPeriodicRestartVMemory;
m_dwPeriodicRestartUMemory = model.m_dwPeriodicRestartUMemory;
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_DebuggerParams = model.m_DebuggerParams;
m_dwIdentType = model.m_dwIdentType;
m_strUserName = model.m_strUserName;
m_strUserPass = model.m_strUserPass;
}
HRESULT
CAppPoolProps::ChangeState(DWORD dwCommand)
/*++
Routine Description:
Change the state of the pool
Arguments:
DWORD dwCommand : Command
Return Value:
HRESULT
--*/
{
DWORD dwTargetState;
DWORD dwPendingState;
CError err;
switch(dwCommand)
{
case MD_APPPOOL_COMMAND_STOP:
dwTargetState = MD_APPPOOL_STATE_STOPPED;
dwPendingState = MD_APPPOOL_STATE_STOPPING;
break;
case MD_APPPOOL_COMMAND_START:
dwTargetState = MD_APPPOOL_STATE_STARTED;
dwPendingState = MD_APPPOOL_STATE_STARTING;
break;
default:
ASSERT_MSG("Invalid service state requested");
err = ERROR_INVALID_PARAMETER;
}
err = OpenForWriting(FALSE);
if (err.Succeeded())
{
m_dwWin32Error = 0;
err = SetValue(MD_WIN32_ERROR, m_dwWin32Error);
if (err.Succeeded())
{
err = SetValue(MD_APPPOOL_COMMAND, dwCommand);
}
Close();
}
if (err.Succeeded())
{
//
// Wait for the service to attain desired state, timeout
// after specified interval
//
DWORD dwSleepTotal = 0L;
DWORD dwOldState = m_dwState;
if (dwOldState == dwTargetState)
{
//
// Current state matches desired
// state already. ISM must be behind
// the times.
//
return err;
}
while (dwSleepTotal < MAX_SLEEP_POOL)
{
err = LoadData();
if (err.Failed())
{
break;
}
if ((m_dwState != dwPendingState && m_dwState != dwOldState)
|| m_dwWin32Error != ERROR_SUCCESS
)
{
//
// Done one way or another
//
if (m_dwState != dwTargetState)
{
//
// Did not achieve desired result. Something went
// wrong.
//
if (m_dwWin32Error)
{
err = m_dwWin32Error;
}
}
break;
}
//
// Still pending...
//
::Sleep(SLEEP_INTERVAL);
dwSleepTotal += SLEEP_INTERVAL;
}
if (dwSleepTotal >= MAX_SLEEP_POOL)
{
//
// Timed out. If there is a real error in the metabase
// use it, otherwise use a generic timeout error
//
// err = m_dwWin32Error;
if (err.Succeeded())
{
err = ERROR_SERVICE_REQUEST_TIMEOUT;
}
}
}
return err;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////
IMPLEMENT_DYNAMIC(CAppPoolSheet, CInetPropertySheet)
CAppPoolSheet::CAppPoolSheet(
CComAuthInfo * pAuthInfo,
LPCTSTR lpszMetaPath,
CWnd * pParentWnd,
LPARAM lParam,
LPARAM lParamParent,
UINT iSelectPage
)
: CInetPropertySheet(
pAuthInfo, lpszMetaPath, pParentWnd, lParam, lParamParent, 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();
}
}
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(CAppPoolRecycle, CInetPropertyPage)
CAppPoolRecycle::CAppPoolRecycle(CInetPropertySheet * pSheet)
: CInetPropertyPage(CAppPoolRecycle::IDD, pSheet),
m_fDoRestartOnTime(FALSE),
m_dwPeriodicRestartTime(PERIODIC_RESTART_TIME_DEF),
m_fDoRestartOnCount(FALSE),
m_dwRestartRequestCount(PERIODIC_RESTART_REQ_DEF),
m_fDoRestartOnSchedule(FALSE),
m_fDoRestartOnVMemory(FALSE),
m_fDoRestartOnUMemory(FALSE),
m_dwPeriodicRestartVMemory(VMEMORY_DEF * 1024),
m_dwPeriodicRestartUMemory(UMEMORY_DEF * 1024)
{
}
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_dwPeriodicRestartVMemory);
FETCH_INST_DATA_FROM_SHEET(m_dwPeriodicRestartUMemory);
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_fDoRestartOnVMemory = m_dwPeriodicRestartVMemory != 0;
if (!m_fDoRestartOnVMemory)
{
m_dwPeriodicRestartVMemoryDisplay = VMEMORY_DEF;
}
else
{
m_dwPeriodicRestartVMemoryDisplay = m_dwPeriodicRestartVMemory / 1024;
}
m_fDoRestartOnUMemory = m_dwPeriodicRestartUMemory != 0;
if (!m_fDoRestartOnUMemory)
{
m_dwPeriodicRestartUMemoryDisplay = UMEMORY_DEF;
}
else
{
m_dwPeriodicRestartUMemoryDisplay = m_dwPeriodicRestartUMemory / 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)
{
CString buf;
for (int i = 0; i < count; i++)
{
buf = (LPCTSTR)m_lst_Schedule.GetItemDataPtr(i);
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_dwPeriodicRestartVMemory = m_dwPeriodicRestartVMemoryDisplay * 1024;
if (!m_fDoRestartOnVMemory)
m_dwPeriodicRestartVMemory = 0;
STORE_INST_DATA_ON_SHEET(m_dwPeriodicRestartVMemory)
m_dwPeriodicRestartUMemory = m_dwPeriodicRestartUMemoryDisplay * 1024;
if (!m_fDoRestartOnUMemory)
m_dwPeriodicRestartUMemory = 0;
STORE_INST_DATA_ON_SHEET(m_dwPeriodicRestartUMemory)
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);
// This Needs to come before DDX_Text which will try to put text big number into small number
DDV_MinMaxBalloon(pDX, IDC_TIMESPAN, TIMESPAN_MIN, TIMESPAN_MAX);
DDX_TextBalloon(pDX, IDC_TIMESPAN, m_dwPeriodicRestartTime);
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);
// This Needs to come before DDX_Text which will try to put text big number into small number
DDV_MinMaxBalloon(pDX, IDC_REQUEST_LIMIT, REQUESTS_MIN, REQUESTS_MAX);
DDX_TextBalloon(pDX, IDC_REQUEST_LIMIT, m_dwRestartRequestCount);
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_VMEMORY, m_fDoRestartOnVMemory);
DDX_Control(pDX, IDC_RECYCLE_VMEMORY, m_btn_DoRestartOnVMemory);
// This Needs to come before DDX_Text which will try to put text big number into small number
DDV_MinMaxBalloon(pDX, IDC_VMEMORY_LIMIT, VMEMORY_MIN, VMEMORY_MAX);
DDX_TextBalloon(pDX, IDC_VMEMORY_LIMIT, m_dwPeriodicRestartVMemoryDisplay);
DDX_Control(pDX, IDC_VMEMORY_LIMIT, m_VMemoryLimit);
DDX_Control(pDX, IDC_VMEMORY_SPIN, m_VMemoryLimitSpin);
DDX_Check(pDX, IDC_RECYCLE_UMEMORY, m_fDoRestartOnUMemory);
DDX_Control(pDX, IDC_RECYCLE_UMEMORY, m_btn_DoRestartOnUMemory);
// This Needs to come before DDX_Text which will try to put text big number into small number
DDV_MinMaxBalloon(pDX, IDC_UMEMORY_LIMIT, UMEMORY_MIN, UMEMORY_MAX);
DDX_TextBalloon(pDX, IDC_UMEMORY_LIMIT, m_dwPeriodicRestartUMemoryDisplay);
DDX_Control(pDX, IDC_UMEMORY_LIMIT, m_UMemoryLimit);
DDX_Control(pDX, IDC_UMEMORY_SPIN, m_UMemoryLimitSpin);
//}}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_VMEMORY, OnDoRestartOnVMemory)
ON_BN_CLICKED(IDC_RECYCLE_UMEMORY, OnDoRestartOnUMemory)
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_VMEMORY_LIMIT, OnItemChanged)
ON_EN_CHANGE(IDC_UMEMORY_LIMIT, OnItemChanged)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
BOOL
CAppPoolRecycle::OnInitDialog()
{
UDACCEL toAcc[3] = {{1, 1}, {3, 5}, {6, 10}};
CInetPropertyPage::OnInitDialog();
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_fDoRestartOnVMemory, m_VMemoryLimit, m_VMemoryLimitSpin,
VMEMORY_MIN, VMEMORY_MAX, m_dwPeriodicRestartVMemoryDisplay);
SETUP_EDIT_SPIN(m_fDoRestartOnUMemory, m_UMemoryLimit, m_UMemoryLimitSpin,
UMEMORY_MIN, UMEMORY_MAX, m_dwPeriodicRestartUMemoryDisplay);
POSITION pos = m_RestartSchedule.GetHeadPosition();
while (pos != NULL)
{
CString& str = m_RestartSchedule.GetNext(pos);
m_lst_Schedule.AddString(str);
}
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_VMemoryLimit.EnableWindow(m_fDoRestartOnVMemory);
m_VMemoryLimitSpin.EnableWindow(m_fDoRestartOnVMemory);
m_UMemoryLimit.EnableWindow(m_fDoRestartOnUMemory);
m_UMemoryLimitSpin.EnableWindow(m_fDoRestartOnUMemory);
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);
LPCTSTR p1 = (LPCTSTR)cmpi->itemData1;
LPCTSTR p2 = (LPCTSTR)cmpi->itemData2;
return StrCmp(p1, p2);
}
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)
{
LPCTSTR p = (LPCTSTR)di->itemData;
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, p, -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::OnDoRestartOnVMemory()
{
m_fDoRestartOnVMemory = !m_fDoRestartOnVMemory;
SetControlsState();
SetModified(TRUE);
}
void
CAppPoolRecycle::OnDoRestartOnUMemory()
{
m_fDoRestartOnUMemory = !m_fDoRestartOnUMemory;
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;
TCHAR buf[6];
CTime tm = dlg.GetTime();
wsprintf(buf, _T("%02d:%02d"), tm.GetHour(), tm.GetMinute());
if ((idx = m_lst_Schedule.FindString(-1, buf)) == LB_ERR)
{
idx = m_lst_Schedule.AddString(StrDup(buf));
m_lst_Schedule.SetCurSel(idx);
m_btn_Edit.EnableWindow(idx != LB_ERR);
m_btn_Remove.EnableWindow(idx != LB_ERR);
SetModified(idx != LB_ERR);
}
m_lst_Schedule.SetCurSel(idx);
}
}
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();
CString ts = (LPCTSTR)m_lst_Schedule.GetItemDataPtr(idx);
// Looks like we have to init the struct properly
SYSTEMTIME tm;
::GetSystemTime(&tm);
int n = ts.Find(_T(':'));
int len = ts.GetLength();
tm.wMinute = (WORD)StrToInt(ts.Right(len - n - 1));
tm.wHour = (WORD)StrToInt(ts.Left(n));
tm.wSecond = 0;
dlg.SetTime(CTime(tm));
if (dlg.DoModal() == IDOK)
{
CTime time = dlg.GetTime();
TCHAR buf[6];
wsprintf(buf, _T("%02d:%02d"), time.GetHour(), time.GetMinute());
int idx2;
if ((idx2 = m_lst_Schedule.FindString(-1, buf)) == LB_ERR)
{
m_lst_Schedule.DeleteString(idx);
idx2 = m_lst_Schedule.AddString(StrDup(buf));
m_lst_Schedule.GetItemRect(idx2, &rc);
m_lst_Schedule.InvalidateRect(&rc, TRUE);
SetModified(TRUE);
}
m_lst_Schedule.SetCurSel(idx2);
}
}
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 * 1000),
m_dwRefreshTime(0),
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_fDoIdleShutdown = m_dwIdleTimeout != 0;
if (!m_fDoIdleShutdown)
{
m_dwIdleTimeout = IDLE_TIMEOUT_DEF;
}
m_fDoLimitQueue = m_dwQueueSize != (DWORD)65535;
if (!m_fDoLimitQueue)
{
m_dwQueueSize = QUEUE_SIZE_DEF;
}
m_fDoEnableCPUAccount = m_dwMaxCPU_Use > 0 /*&& m_dwRefreshTime > 0*/;
if (!m_fDoEnableCPUAccount)
{
m_dwMaxCPU_UseVisual = CPU_USE_DEF;
m_dwRefreshTime = CPU_RESET_TIME_DEF;
m_ActionIndex = ACTION_INDEX_DEF;
}
else
{
m_dwMaxCPU_UseVisual = m_dwMaxCPU_Use / 1000;
}
return err;
}
/* virtual */
HRESULT
CAppPoolPerf::SaveInfo()
{
ASSERT(IsDirty());
CError err;
m_dwMaxCPU_Use = m_dwMaxCPU_UseVisual * 1000;
DWORD t = m_dwIdleTimeout;
DWORD q = m_dwQueueSize;
DWORD r = m_dwRefreshTime;
BEGIN_META_INST_WRITE(CAppPoolSheet)
if (!m_fDoIdleShutdown)
{
m_dwIdleTimeout = 0;
}
if (!m_fDoLimitQueue)
{
m_dwQueueSize = (DWORD)65535;
}
if (!m_fDoEnableCPUAccount)
{
// m_dwRefreshTime = 0;
m_dwMaxCPU_Use = 0;
}
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)
m_dwQueueSize = q;
m_dwIdleTimeout = t;
m_dwRefreshTime = r;
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);
// This Needs to come before DDX_Text which will try to put text big number into small number
DDV_MinMaxBalloon(pDX, IDC_IDLETIME, TIMEOUT_MIN, TIMEOUT_MAX);
DDX_TextBalloon(pDX, IDC_IDLETIME, m_dwIdleTimeout);
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);
// This Needs to come before DDX_Text which will try to put text big number into small number
DDV_MinMaxBalloon(pDX, IDC_QUEUESIZE, QUEUESIZE_MIN, QUEUESIZE_MAX);
DDX_TextBalloon(pDX, IDC_QUEUESIZE, m_dwQueueSize);
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);
// This Needs to come before DDX_Text which will try to put text big number into small number
DDV_MinMaxBalloon(pDX, IDC_CPU_USE, CPU_LIMIT_MIN, CPU_LIMIT_MAX);
DDX_TextBalloon(pDX, IDC_CPU_USE, m_dwMaxCPU_UseVisual);
DDX_Control(pDX, IDC_CPU_USE, m_MaxCPU_Use);
DDX_Control(pDX, IDC_CPU_USE_SPIN, m_MaxCPU_UseSpin);
// This Needs to come before DDX_Text which will try to put text big number into small number
DDV_MinMaxBalloon(pDX, IDC_REFRESHTIME, CPU_RESET_TIME_MIN, CPU_RESET_TIME_MAX);
DDX_TextBalloon(pDX, IDC_REFRESHTIME, m_dwRefreshTime);
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);
// This Needs to come before DDX_Text which will try to put text big number into small number
DDV_MinMaxBalloon(pDX, IDC_MAXPROCESSES, MAXPROCESSES_MIN, MAXPROCESSES_MAX);
DDX_TextBalloon(pDX, IDC_MAXPROCESSES, m_dwMaxProcesses);
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);
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 > 1)
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(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)
{
}
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);
// This Needs to come before DDX_Text which will try to put text big number into small number
DDV_MinMaxBalloon(pDX, IDC_PINGINTERVAL, PING_INTERVAL_MIN, PING_INTERVAL_MAX);
DDX_TextBalloon(pDX, IDC_PINGINTERVAL, m_dwPingInterval);
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);
// This Needs to come before DDX_Text which will try to put text big number into small number
DDV_MinMaxBalloon(pDX, IDC_CRASHES_COUNT, CRASHES_COUNT_MIN, CRASHES_COUNT_MAX);
DDX_TextBalloon(pDX, IDC_CRASHES_COUNT, m_dwCrashesCount);
DDX_Control(pDX, IDC_CRASHES_COUNT, m_CrashesCount);
DDX_Control(pDX, IDC_CRASHES_COUNT_SPIN, m_CrashesCountSpin);
// This Needs to come before DDX_Text which will try to put text big number into small number
DDV_MinMaxBalloon(pDX, IDC_CHECK_TIME, CHECK_INTERVAL_MIN, CHECK_INTERVAL_MAX);
DDX_TextBalloon(pDX, IDC_CHECK_TIME, m_dwCheckInterval);
DDX_Control(pDX, IDC_CHECK_TIME, m_CheckInterval);
DDX_Control(pDX, IDC_CHECK_TIME_SPIN, m_CheckIntervalSpin);
// This Needs to come before DDX_Text which will try to put text big number into small number
DDV_MinMaxBalloon(pDX, IDC_STARTUP_LIMIT, STARTUP_LIMIT_MIN, STARTUP_LIMIT_MAX);
DDX_TextBalloon(pDX, IDC_STARTUP_LIMIT, m_dwStartupLimit);
DDX_Control(pDX, IDC_STARTUP_LIMIT, m_StartupLimit);
DDX_Control(pDX, IDC_STARTUP_LIMIT_SPIN, m_StartupLimitSpin);
// This Needs to come before DDX_Text which will try to put text big number into small number
DDV_MinMaxBalloon(pDX, IDC_SHUTDOWN_LIMIT, SHUTDOWN_LIMIT_MIN, SHUTDOWN_LIMIT_MAX);
DDX_TextBalloon(pDX, IDC_SHUTDOWN_LIMIT, m_dwShutdownLimit);
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);
}
///////////////////////////////////////////////////////////////////////////////////////////
#if 0
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);
FETCH_INST_DATA_FROM_SHEET(m_DebuggerParams);
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);
STORE_INST_DATA_ON_SHEET(m_DebuggerParams);
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_Control(pDX, IDC_FILE_NAME, m_FileName);
DDX_Control(pDX, IDC_BROWSE, m_Browse);
DDX_Text(pDX, IDC_PARAMETERS, m_DebuggerParams);
DDX_Control(pDX, IDC_PARAMETERS, m_Params);
//}}AFX_DATA_MAP
DDX_Text(pDX, IDC_FILE_NAME, m_DebuggerFileName);
if (pDX->m_bSaveAndValidate && m_fDoEnableDebug)
{
DDV_FilePath(pDX, m_DebuggerFileName, GetSheet()->IsLocal());
}
}
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)
ON_EN_CHANGE(IDC_PARAMETERS, OnItemChanged)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
BOOL
CAppPoolDebug::OnInitDialog()
{
CInetPropertyPage::OnInitDialog();
if (m_DebuggerFileName.IsEmpty())
m_fDoEnableDebug = FALSE;
SetControlState();
#ifdef SUPPORT_SLASH_SLASH_QUESTIONMARK_SLASH_TYPE_PATHS
LimitInputPath(CONTROL_HWND(IDC_FILE_NAME),TRUE);
#else
LimitInputPath(CONTROL_HWND(IDC_FILE_NAME),FALSE);
#endif
return TRUE;
}
void
CAppPoolDebug::SetControlState()
{
m_bnt_DoEnableDebug.SetCheck(m_fDoEnableDebug);
m_FileName.EnableWindow(m_fDoEnableDebug);
m_Browse.EnableWindow(GetSheet()->IsLocal() && m_fDoEnableDebug);
m_Params.EnableWindow(m_fDoEnableDebug);
}
void
CAppPoolDebug::OnItemChanged()
{
SetModified(TRUE);
}
void
CAppPoolDebug::OnDoEnableDebug()
{
m_fDoEnableDebug = !m_fDoEnableDebug;
SetControlState();
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();
}
#endif
/////////////////////////////////////////////////////////////////////////////////////
#define LOCAL_SYSTEM_IDX 2
#define LOCAL_SERVICE_IDX 1
#define NETWORK_SERVICE_IDX 0
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_PASSWORD(m_strUserPass);
END_META_INST_READ(err)
m_fPredefined = m_dwIdentType != IDENT_TYPE_CONFIGURABLE;
switch (m_dwIdentType)
{
case IDENT_TYPE_LOCALSYSTEM:
m_PredefIndex = LOCAL_SYSTEM_IDX;
break;
case IDENT_TYPE_LOCALSERVICE:
m_PredefIndex = LOCAL_SERVICE_IDX;
break;
case IDENT_TYPE_NETWORKSERVICE:
m_PredefIndex = NETWORK_SERVICE_IDX;
break;
default:
m_PredefIndex = -1;
break;
}
return err;
}
/* virtual */
HRESULT
CAppPoolIdent::SaveInfo()
{
ASSERT(IsDirty());
CError err;
BEGIN_META_INST_WRITE(CAppPoolSheet)
if (m_fPredefined)
{
switch (m_PredefIndex)
{
case LOCAL_SYSTEM_IDX:
m_dwIdentType = IDENT_TYPE_LOCALSYSTEM;
break;
case LOCAL_SERVICE_IDX:
m_dwIdentType = IDENT_TYPE_LOCALSERVICE;
break;
case NETWORK_SERVICE_IDX:
m_dwIdentType = IDENT_TYPE_NETWORKSERVICE;
break;
default:
break;
}
}
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_Password(pDX, IDC_USER_PASS, m_strUserPass, _T("***********"));
DDX_Password_SecuredString(pDX, IDC_USER_PASS, m_strUserPass, _T("***********"));
DDX_Control(pDX, IDC_USER_PASS, m_UserPass);
//}}AFX_DATA_MAP
if (pDX->m_bSaveAndValidate
&& m_fPredefined
&& m_PredefIndex == LOCAL_SYSTEM_IDX
&& !m_bAssCovered
)
{
if (IsDirty())
{
if (!NoYesMessageBox(IDS_SYSIDENT_CONFIRM))
{
m_PredefList.SetFocus();
pDX->Fail();
}
m_bAssCovered = TRUE;
}
}
}
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, OnSysAccountChanged)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
BOOL
CAppPoolIdent::OnInitDialog()
{
CInetPropertyPage::OnInitDialog();
CString buf;
buf.LoadString(IDS_NETSERVICE);
m_PredefList.AddString(buf);
buf.LoadString(IDS_LOCALSERVICE);
m_PredefList.AddString(buf);
buf.LoadString(IDS_LOCALSYSTEM);
m_PredefList.AddString(buf);
if (!m_fPredefined)
{
m_PredefIndex = 0;
}
m_PredefList.SetCurSel(m_PredefIndex);
SetControlState();
m_bAssCovered = FALSE;
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;
SetModified(TRUE);
UpdateData(FALSE);
}
}
void
CAppPoolIdent::OnItemChanged()
{
SetModified(TRUE);
}
void
CAppPoolIdent::OnSysAccountChanged()
{
SetModified(TRUE);
}
#if 0
HRESULT
CAppPoolCache::FetchLoadedValues()
{
CError err;
BEGIN_META_INST_READ(CAppPoolSheet)
FETCH_INST_DATA_FROM_SHEET(m_ScriptEngCacheMax);
FETCH_INST_DATA_FROM_SHEET(m_NoCache);
FETCH_INST_DATA_FROM_SHEET(m_LimCache);
FETCH_INST_DATA_FROM_SHEET(m_UnlimCache);
FETCH_INST_DATA_FROM_SHEET(m_LimDiskCache);
FETCH_INST_DATA_FROM_SHEET(m_LimCacheMemSize);
FETCH_INST_DATA_FROM_SHEET(m_LimCacheDiskSize);
FETCH_INST_DATA_FROM_SHEET(m_DiskCacheDir);
END_META_INST_READ(err)
return err;
}
HRESULT
CAppPoolCache::SaveInfo()
{
ASSERT(IsDirty());
CError err;
BEGIN_META_INST_WRITE(CAppPoolSheet)
STORE_INST_DATA_ON_SHEET(m_ScriptEngCacheMax)
STORE_INST_DATA_ON_SHEET(m_NoCache);
STORE_INST_DATA_ON_SHEET(m_LimCache);
STORE_INST_DATA_ON_SHEET(m_UnlimCache);
STORE_INST_DATA_ON_SHEET(m_LimDiskCache);
STORE_INST_DATA_ON_SHEET(m_LimCacheMemSize);
STORE_INST_DATA_ON_SHEET(m_LimCacheDiskSize);
STORE_INST_DATA_ON_SHEET(m_DiskCacheDir);
END_META_INST_WRITE(err)
return err;
}
HRESULT
CPoolProcessOpt::FetchLoadedValues()
{
CError err;
BEGIN_META_INST_READ(CAppPoolSheet)
FETCH_INST_DATA_FROM_SHEET(m_LogFailures);
FETCH_INST_DATA_FROM_SHEET(m_DebugExcept);
FETCH_INST_DATA_FROM_SHEET(m_CgiTimeout);
FETCH_INST_DATA_FROM_SHEET(m_HTMLFallback);
END_META_INST_READ(err)
return err;
}
HRESULT
CPoolProcessOpt::SaveInfo()
{
ASSERT(IsDirty());
CError err;
BEGIN_META_INST_WRITE(CAppPoolSheet)
STORE_INST_DATA_ON_SHEET(m_LogFailures);
STORE_INST_DATA_ON_SHEET(m_DebugExcept);
STORE_INST_DATA_ON_SHEET(m_CgiTimeout);
STORE_INST_DATA_ON_SHEET(m_HTMLFallback);
END_META_INST_WRITE(err)
return err;
}
#endif