STDMETHODIMP CLogFactory::LogMonitor(LONG Handle, BSTR FileName)
{
MONITOR Data;
Data.Handle = Handle;
Data.FileName = CString(FileName);
if (0 != Handle)
{
m_arrMonitor.Add(Data);
LONG Count = LockServer();
LOGGER_WRITE(_T("增加监控, 服务计数:") << Count);
}
else
{
m_arrMonitor.Delete(Data);
LONG Count = UnlockServer();
LOGGER_WRITE(_T("删除监控, 服务计数:") << Count);
}
for (INT i = 0; i < MAX_SERVER_COUNT; i++)
{
LOGSERVER &LogServer = m_sLogServer[i];
if (0 != LogServer.iClient)
{
CLogWriter &oLogServer = LogServer.oLogServer;
oLogServer.SetMonitor(Handle, CString(FileName));
return S_OK;
}
}
return S_OK;
}
////////////////////////////////////////////////////////////////////////
// IClassFactory
//
////////////////////////////////////////////////////////////////////////
// CreateInstance
//
STDMETHODIMP CRatDVDClassFactory::CreateInstance(LPUNKNOWN punk, REFIID riid, void** ppv)
{
HRESULT hr;
ODS(_T("CFileClassFactory::CreateInstance\n"));
CHECK_NULL_RETURN(ppv, E_POINTER); *ppv = NULL;
// This version does not support Aggregation...
if (punk) return CLASS_E_NOAGGREGATION;
if ( IID_ILibraryBuilderPlugin == riid || IID_IImageServicePlugin == riid )
{
CComObject<CRatDVDPlugin>*pRatDVDPlugin = new CComObject<CRatDVDPlugin>;
CHECK_NULL_RETURN(pRatDVDPlugin, E_OUTOFMEMORY);
hr = pRatDVDPlugin->QueryInterface( IID_IUnknown, ppv );
if ( SUCCEEDED(hr) )
{
if ( IID_ILibraryBuilderPlugin == riid )
*ppv = dynamic_cast<ILibraryBuilderPlugin*>(pRatDVDPlugin);
else
*ppv = dynamic_cast<IImageServicePlugin*>(pRatDVDPlugin);
}
else return hr;
}
else return E_NOINTERFACE;
LockServer(TRUE); // on success, bump up lock count
return hr;
}
//
// Constructor
//
GitWCRev::GitWCRev()
: m_cRef(1)
, GitStat()
, m_ptinfo(nullptr)
{
LockServer(true);
LoadTypeInfo(&m_ptinfo, LIBID_LibGitWCRev, IID_IGitWCRev, 0);
}
////////////////////////////////////////////////////////////////////////
// Release
//
STDMETHODIMP_(ULONG) CRatDVDClassFactory::Release(void)
{
if ( 0 != --m_cRef ) return m_cRef;
ODS(_T("CRatDVDClassFactory delete\n"));
LockServer(FALSE);
return 0;
}
STDMETHODIMP CLogFactory::Create(LONG FileType,
BSTR AppName,
BSTR Configue,
BSTR Section,
BSTR* LogName,
BSTR* XFile)
{
//MessageBox(NULL, _T("CLogFactory::Create"), _T("CLogFactory::Create"), MB_OK);
ATLASSERT(NULL != AppName);
ATLASSERT(NULL != Configue);
ATLASSERT(NULL != Section);
if (NULL == AppName
|| NULL == Configue
|| NULL == Section
|| NULL == LogName)
{
CString strError = _T("AppName(or Configue? Section? LogName?) is NULL. CLogFactory::Create return E_FAIL.");
LOGGER_WRITE(strError.GetBuffer());
LogEvent(strError);
return E_FAIL;
}
CString strLogName;
if (!CreateLogName(AppName, Configue, Section, FileType, strLogName))
return E_FAIL;
int iSerIndex = -1;
if (!FindObject(strLogName, iSerIndex))
{
if (!CreateObject(strLogName, FileType, AppName, Configue, Section, iSerIndex))
return E_FAIL;
}
ATLASSERT(-1 != iSerIndex);
LOGSERVER &LogServer = m_sLogServer[iSerIndex];
LogServer.oClientName.Add(CString(AppName));
LONG Count = LockServer();
LOGGER_WRITE(_T("增加客户端, 服务计数:") << Count);
*LogName = strLogName.AllocSysString();
TCHAR Buffer[MAX_PATH] = { 0 };
GetModuleFileName(GetModuleHandle(NULL), Buffer, MAX_PATH - 1);
CString ModuleFile(Buffer);
*XFile = ModuleFile.AllocSysString();
return S_OK;
}
void
OsInit(void)
{
static Bool been_here = FALSE;
static char* admpath = ADMPATH;
static char* devnull = "/dev/null";
char fname[PATH_MAX];
if (!been_here) {
struct sigaction act, oact;
int i;
int siglist[] = { SIGSEGV, SIGQUIT, SIGILL, SIGFPE, SIGBUS,
#ifdef SIGSYS
SIGSYS,
#endif
#ifdef SIGXCPU
SIGXCPU,
#endif
#ifdef SIGXFSZ
SIGXFSZ,
#endif
#ifdef SIGEMT
SIGEMT,
#endif
0 /* must be last */ };
sigemptyset(&act.sa_mask);
#ifdef SA_SIGINFO
act.sa_sigaction = OsSigHandler;
act.sa_flags = SA_SIGINFO;
#else
act.sa_handler = OsSigHandler;
act.sa_flags = 0;
#endif
for (i = 0; siglist[i] != 0; i++) {
if (sigaction(siglist[i], &act, &oact)) {
ErrorF("failed to install signal handler for signal %d: %s\n",
siglist[i], strerror(errno));
}
}
#ifdef HAVE_BACKTRACE
/*
* initialize the backtracer, since the ctor calls dlopen(), which
* calls malloc(), which isn't signal-safe.
*/
do {
void *array;
backtrace(&array, 1);
} while (0);
#endif
#ifdef RTLD_DI_SETSIGNAL
/* Tell runtime linker to send a signal we can catch instead of SIGKILL
* for failures to load libraries/modules at runtime so we can clean up
* after ourselves.
*/
int failure_signal = SIGQUIT;
dlinfo(RTLD_SELF, RTLD_DI_SETSIGNAL, &failure_signal);
#endif
#if !defined(__SCO__) && !defined(__CYGWIN__) && !defined(__UNIXWARE__)
fclose(stdin);
fclose(stdout);
#endif
/*
* If a write of zero bytes to stderr returns non-zero, i.e. -1,
* then writing to stderr failed, and we'll write somewhere else
* instead. (Apparently this never happens in the Real World.)
*/
if (write (2, fname, 0) == -1)
{
FILE *err;
if (strlen (display) + strlen (admpath) + 1 < sizeof fname)
sprintf (fname, admpath, display);
else
strcpy (fname, devnull);
/*
* uses stdio to avoid os dependencies here,
* a real os would use
* open (fname, O_WRONLY|O_APPEND|O_CREAT, 0666)
*/
if (!(err = fopen (fname, "a+")))
err = fopen (devnull, "w");
if (err && (fileno(err) != 2)) {
dup2 (fileno (err), 2);
fclose (err);
}
#if defined(SYSV) || defined(SVR4) || defined(WIN32) || defined(__CYGWIN__)
{
static char buf[BUFSIZ];
setvbuf (stderr, buf, _IOLBF, BUFSIZ);
}
#else
setlinebuf(stderr);
#endif
}
if (getpgrp () == 0)
setpgid (0, 0);
#ifdef RLIMIT_DATA
if (limitDataSpace >= 0)
{
struct rlimit rlim;
if (!getrlimit(RLIMIT_DATA, &rlim))
{
if ((limitDataSpace > 0) && (limitDataSpace < rlim.rlim_max))
rlim.rlim_cur = limitDataSpace;
else
rlim.rlim_cur = rlim.rlim_max;
(void)setrlimit(RLIMIT_DATA, &rlim);
}
}
#endif
#ifdef RLIMIT_STACK
if (limitStackSpace >= 0)
{
struct rlimit rlim;
if (!getrlimit(RLIMIT_STACK, &rlim))
{
if ((limitStackSpace > 0) && (limitStackSpace < rlim.rlim_max))
rlim.rlim_cur = limitStackSpace;
else
rlim.rlim_cur = rlim.rlim_max;
(void)setrlimit(RLIMIT_STACK, &rlim);
}
}
#endif
#ifdef RLIMIT_NOFILE
if (limitNoFile >= 0)
{
struct rlimit rlim;
if (!getrlimit(RLIMIT_NOFILE, &rlim))
{
if ((limitNoFile > 0) && (limitNoFile < rlim.rlim_max))
rlim.rlim_cur = limitNoFile;
else
rlim.rlim_cur = rlim.rlim_max;
(void)setrlimit(RLIMIT_NOFILE, &rlim);
}
}
#endif
LockServer();
been_here = TRUE;
}
TimerInit();
OsVendorInit();
/*
* No log file by default. OsVendorInit() should call LogInit() with the
* log file name if logging to a file is desired.
*/
LogInit(NULL, NULL);
if (!SmartScheduleDisable)
if (!SmartScheduleInit ())
SmartScheduleDisable = TRUE;
}
void
OsInit(void)
{
static Bool been_here = FALSE;
static char* admpath = ADMPATH;
static char* devnull = "/dev/null";
char fname[PATH_MAX];
#ifdef macII
set42sig();
#endif
if (!been_here) {
#if !defined(__SCO__) && !defined(__CYGWIN__) && !defined(__UNIXWARE__)
fclose(stdin);
fclose(stdout);
#endif
/*
* If a write of zero bytes to stderr returns non-zero, i.e. -1,
* then writing to stderr failed, and we'll write somewhere else
* instead. (Apparently this never happens in the Real World.)
*/
if (write (2, fname, 0) == -1)
{
FILE *err;
if (strlen (display) + strlen (admpath) + 1 < sizeof fname)
sprintf (fname, admpath, display);
else
strcpy (fname, devnull);
/*
* uses stdio to avoid os dependencies here,
* a real os would use
* open (fname, O_WRONLY|O_APPEND|O_CREAT, 0666)
*/
if (!(err = fopen (fname, "a+")))
err = fopen (devnull, "w");
if (err && (fileno(err) != 2)) {
dup2 (fileno (err), 2);
fclose (err);
}
#if defined(SYSV) || defined(SVR4) || defined(__UNIXOS2__) || defined(WIN32) || defined(__CYGWIN__)
{
static char buf[BUFSIZ];
setvbuf (stderr, buf, _IOLBF, BUFSIZ);
}
#else
setlinebuf(stderr);
#endif
}
#ifndef X_NOT_POSIX
if (getpgrp () == 0)
setpgid (0, 0);
#else
#if !defined(SYSV) && !defined(WIN32)
if (getpgrp (0) == 0)
setpgrp (0, getpid ());
#endif
#endif
#ifdef RLIMIT_DATA
if (limitDataSpace >= 0)
{
struct rlimit rlim;
if (!getrlimit(RLIMIT_DATA, &rlim))
{
if ((limitDataSpace > 0) && (limitDataSpace < rlim.rlim_max))
rlim.rlim_cur = limitDataSpace;
else
rlim.rlim_cur = rlim.rlim_max;
(void)setrlimit(RLIMIT_DATA, &rlim);
}
}
#endif
#ifdef RLIMIT_STACK
if (limitStackSpace >= 0)
{
struct rlimit rlim;
if (!getrlimit(RLIMIT_STACK, &rlim))
{
if ((limitStackSpace > 0) && (limitStackSpace < rlim.rlim_max))
rlim.rlim_cur = limitStackSpace;
else
rlim.rlim_cur = rlim.rlim_max;
(void)setrlimit(RLIMIT_STACK, &rlim);
}
}
#endif
#ifdef RLIMIT_NOFILE
if (limitNoFile >= 0)
{
struct rlimit rlim;
if (!getrlimit(RLIMIT_NOFILE, &rlim))
{
if ((limitNoFile > 0) && (limitNoFile < rlim.rlim_max))
rlim.rlim_cur = limitNoFile;
else
rlim.rlim_cur = rlim.rlim_max;
#if 0
if (rlim.rlim_cur > MAXSOCKS)
rlim.rlim_cur = MAXSOCKS;
#endif
(void)setrlimit(RLIMIT_NOFILE, &rlim);
}
}
#endif
#ifdef SERVER_LOCK
LockServer();
#endif
been_here = TRUE;
}
TimerInit();
#ifdef DDXOSINIT
OsVendorInit();
#endif
/*
* No log file by default. OsVendorInit() should call LogInit() with the
* log file name if logging to a file is desired.
*/
LogInit(NULL, NULL);
#ifdef SMART_SCHEDULE
if (!SmartScheduleDisable)
if (!SmartScheduleInit ())
SmartScheduleDisable = TRUE;
#endif
OsInitAllocator();
if (!OsDelayInitColors) OsInitColors();
}
//
// Destructor
//
GitWCRev::~GitWCRev()
{
LockServer(false);
if (m_ptinfo)
m_ptinfo->Release();
}
