int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("s:c:"));
int c = -1;
const ACE_TCHAR *client_cmd = 0;
while ((c = get_opts ()) != -1)
switch (c)
{
case 'c':
client_cmd = get_opts.opt_arg ();
ACE_DEBUG ((LM_DEBUG, "Client argument: %s\n", client_cmd));
break;
case 's':
server_cmd = get_opts.opt_arg ();
ACE_DEBUG ((LM_DEBUG, "Server argument: %s\n", server_cmd));
break;
default:
ACE_ERROR_RETURN ((LM_ERROR,
"Usage: collocation_test -s \"server opts\" -c \"client opts\""),
-1);
}
ACE_TCHAR cmd_line[1024];
ACE_OS::strcpy (cmd_line, ACE_TEXT("client "));
if (client_cmd != 0)
ACE_OS::strcat (cmd_line, client_cmd);
ACE_OS::strcat (cmd_line, ACE_TEXT(" -f ") THE_IOR);
ACE_ARGV args (cmd_line);
Barriers thread_barrier (2);
int retv = 1;
ACE_DEBUG ((LM_DEBUG,
"\n \t IDL_Cubit: Collocation test \n\n"));
ACE_Thread_Manager tm;
tm.spawn (reinterpret_cast<ACE_THR_FUNC> (&svr_worker),
&thread_barrier);
thread_barrier.server_init_.wait ();
ACE_OS::sleep (1);
Cubit_Client cubit_client (1);
// Make sure the server shuts itself down afterward.
if (cubit_client.init (args.argc (), args.argv ()) == -1)
return 1;
else
retv = cubit_client.run ();
thread_barrier.client_fini_.wait ();
tm.wait ();
ACE_OS::unlink (THE_IOR);
return retv;
}
// Listing 4 code/ch13
int ACE_TMAIN (int, ACE_TCHAR *[])
{
ExitHandler eh;
ACE_Thread_Manager tm;
HA_CommandHandler handler (eh);
handler.thr_mgr (&tm);
handler.activate ();
tm.wait();
return 0;
}
int
ACE_TMAIN (int, ACE_TCHAR *[])
{
// Message queue.
ACE_Message_Queue<ACE_MT_SYNCH> msg_queue (max_queue);
if (thr_mgr.spawn (ACE_THR_FUNC (producer), (void *) &msg_queue,
THR_NEW_LWP | THR_DETACHED) == -1)
ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "spawn"), 1);
// Wait for producer and consumer threads to exit.
thr_mgr.wait ();
return 0;
}
int main (int argc, char *argv[])
{
ACE_LOG_MSG->open (argv[0]);
parse_args (argc, argv);
current_readers = 0; // Possibly already done
current_writers = 0; // Possibly already done
ACE_DEBUG ((LM_DEBUG, "(%t) main thread starting\n"));
if (thr_mgr.spawn_n (n_readers, (ACE_THR_FUNC) reader, 0, THR_NEW_LWP) == -1 ||
thr_mgr.spawn_n (n_writers, (ACE_THR_FUNC) writer, 0, THR_NEW_LWP) == -1)
ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "spawn_n"), 1);
thr_mgr.wait ();
ACE_DEBUG ((LM_DEBUG, "(%t) exiting main thread\n"));
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
if (parse_args (argc, argv) == -1)
return -1;
if (remote)
{
ACE_Remote_Mutex::set_server_address (ACE_INET_Addr (server_port, server_host));
global_rlock = (ACE_Token_Proxy *) new
ACE_Remote_RLock ("THE_TOKEN", ignore_deadlock, debug);
global_wlock = (ACE_Token_Proxy *) new
ACE_Remote_WLock ("THE_TOKEN", ignore_deadlock, debug);
}
else
{
global_rlock = (ACE_Token_Proxy *) new
ACE_Local_RLock ("THE_TOKEN", ignore_deadlock, debug);
global_wlock = (ACE_Token_Proxy *) new
ACE_Local_WLock ("THE_TOKEN", ignore_deadlock, debug);
}
ACE_Thread_Manager mgr;
if (mgr.spawn_n (threads, ACE_THR_FUNC (run_thread),
(void *) 0,
THR_BOUND | SUSPEND) == -1)
ACE_ERROR_RETURN ((LM_DEBUG, "%p\n", "spawn failed"), -1);
#if ! defined (ACE_HAS_PTHREADS)
if (mgr.resume_all () == -1)
ACE_ERROR_RETURN ((LM_DEBUG, "%p\n", "resume failed"), -1);
#endif
mgr.wait ();
return 0;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
if (parse_args (argc, argv) == -1)
return -1;
ACE_Token_Proxy *A; // Mutex *A*.
ACE_Token_Proxy *B; // Mutex *B*.
ACE_Token_Proxy *R; // *R*eader Lock.
ACE_Token_Proxy *W; // *W*riter Lock.
// Depending on the command line arguments, we will create local or
// remote tokens. The names of the tokens are not important as long
// as they are unique.
if (remote)
{
ACE_Remote_Mutex::set_server_address (ACE_INET_Addr (server_port, server_host));
A = new ACE_Remote_Mutex ("R Mutex A", 0, debug);
B = new ACE_Remote_Mutex ("R Mutex B", 0, debug);
R = new ACE_Remote_RLock ("R Reader Lock", 0, debug);
W = new ACE_Remote_WLock ("R Writer Lock", 0, debug);
}
else
{
A = new ACE_Local_Mutex ("L Mutex A", 0, debug);
B = new ACE_Local_Mutex ("L Mutex B", 0, debug);
R = new ACE_Local_RLock ("L Reader Lock", 0, debug);
W = new ACE_Local_WLock ("L Writer Lock", 0, debug);
}
// These collections will be treated as Tokens by the threads.
ACE_Token_Collection collectionAR (debug, "A and Reader");
ACE_Token_Collection collectionAW (debug, "A and Writer");
ACE_Token_Collection collectionBR (debug, "B and Reader");
// AR and BR can run concurrently. Neither AR or BR can run when AW
// is running.
collectionAR.insert (*A);
collectionAR.insert (*R);
collectionAW.insert (*A);
collectionAW.insert (*W);
collectionBR.insert (*B);
collectionBR.insert (*R);
// Spawn off three threads.
ACE_Thread_Manager *mgr = ACE_Thread_Manager::instance ();
if (mgr->spawn (ACE_THR_FUNC (run_thread),
(void *) &collectionAR, THR_BOUND | THR_SUSPENDED) == -1)
ACE_ERROR_RETURN ((LM_DEBUG, "%p\n", "spawn 1 failed"), -1);
if (mgr->spawn (ACE_THR_FUNC (run_thread),
(void *) &collectionAW, THR_BOUND | THR_SUSPENDED) == -1)
ACE_ERROR_RETURN ((LM_DEBUG, "%p\n", "spawn 2 failed"), -1);
if (mgr->spawn (ACE_THR_FUNC (run_thread),
(void *) &collectionBR, THR_BOUND | THR_SUSPENDED) == -1)
ACE_ERROR_RETURN ((LM_DEBUG, "%p\n", "spawn 3 failed"), -1);
#if ! defined (ACE_HAS_PTHREADS)
if (mgr->resume_all () == -1)
ACE_ERROR_RETURN ((LM_DEBUG, "%p\n", "resume failed"), -1);
#endif
// Wait for all threads to exit.
mgr->wait ();
return 0;
}
//---------------------------------------------------------------------------
int ACE_MAIN(int argc, ACE_TCHAR *argv[])
{
// 환경설정 (제일 먼저 초기화 해야함)
procArguments(argc, argv);
// 로그
if(initLog() < 0)
{
printf("로그 초기화를 실패했으므로 프로그램을 종료합니다.\n");
return -1;
}
//-----------------------------------------------------------------------
// 데몬 만들기
//-----------------------------------------------------------------------
// acceptor 가 초기화 된 후 데몬을 만들게 되면, 부모프로세스가 제거되면서
// listen 소켓도 같이 제거된다. 그러므로 acceptor 를 초기화 하기 전에
// 데몬을 먼저 만들어야 한다.
if(Config::instance()->process.daemon == true)
{
if(makeDaemon() < 0)
{
printf("데몬으로 만들기를 실패했으므로 프로그램을 종료합니다.\n");
return -1;
}
}
PAS_NOTICE1("%s", compile_date);
// 시그널 핸들러
PasSignalHandler* pSignalHandler = new PasSignalHandler;
initSignal(pSignalHandler);
//------------------
// 각 모듈의 초기화
//------------------
HTTP::Request::HeaderBuffBytes = HTTP::Response::HeaderBuffBytes = Config::instance()->process.HttpHeaderBufferBytes;
increseFdLimit();
// PAS 공식 로그
char hostName[32];
gethostname(hostName, sizeof(hostName)-1);
PasDataLog::setPasAddr(hostName);
// 메모리 매니저 초기화
//initMessageBlockManager();
if (readMBconfig() < 0)
{
printf("메모리 풀 컨피그 설정값을 확인하세요.\n");
PAS_ERROR("메모리 풀 컨피그 설정값을 확인하세요.\n");
return -1;
}
const int numWorkerThread = Config::instance()->thread.numWorker;
// 리액터
ACE_Reactor* pReactor = ReactorPool::instance()->createMaster();
ReactorPool::instance()->createWorkers(numWorkerThread);
ACE_Reactor* pGlobalReactor = ACE_Reactor::instance();
PAS_NOTICE3("REACTOR: Master=%X, Global=%X, Master=%x",
pReactor, pGlobalReactor, ReactorPool::instance()->masterReactor());
// Listen 포트 설정
PAS_NOTICE("Listen Socket Activate");
PasAcceptor* pAcceptor = new PasAcceptor(pReactor);
const int listenPort = Config::instance()->network.listenPort;
// mIDC 내의 서버를 감시하는 쪽에 mwatch 전달하기 위해 메시지 작성한다.
Util2::setMwatchMsg(listenPort);
// acceptor 기동
if(pAcceptor->open(listenPort) < 0)
{
PAS_ERROR1("Listen 소켓 생성 실패, Port[%d]\n", listenPort);
PAS_ERROR("프로그램 종료\n");
printf("Listen 소켓 생성 실패, Port[%d]\n", listenPort);
printf("프로그램 종료\n");
return -1;
}
// 쓰레드 매니저
ACE_Thread_Manager* pTManager = ACE_Thread_Manager::instance();
// monitor 보고리를 위한 thread 를 생성한다.
MonitorReporter *monitor = MonitorReporter::instance(pTManager);
monitor->activate(THR_NEW_LWP | THR_JOINABLE);
WatchReporter *watch = WatchReporter::instance(pTManager);
watch->activate(THR_NEW_LWP | THR_JOINABLE);
// UserInfo 관리를 위한 thread 를 생성한다.
UserInfoMng *userInfoMng = UserInfoMng::instance(pTManager);
userInfoMng->activate(THR_NEW_LWP | THR_JOINABLE);
// phone trace 를 위한 thread 를 생성한다.
PhoneTraceMng *phoneTraceMng = PhoneTraceMng::instance(pTManager);
phoneTraceMng->setDataFile((char*)"trace.acl");
phoneTraceMng->activate(THR_NEW_LWP | THR_JOINABLE);
// 공지 처리 (Stat Filter) 를 위한 thread 를 생성한다.
StatFilterMng *statFilterMng = StatFilterMng::instance(pTManager);
statFilterMng->setDataFile((char*)"k_stat.cfg");
statFilterMng->activate(THR_NEW_LWP | THR_JOINABLE);
// ACL 초기화
if(Config::instance()->acl.enable)
initACL();
CGI::cgiSetupConstants();
// Create AuthAgent Thread
AuthAgent *authAgent = AuthAgent::instance(pTManager);
authAgent->activate(THR_NEW_LWP | THR_JOINABLE);
//usleep(1000);
// 내부 정보 (sysinfo) 출력를 위한 Thread
SysInfo *sysInfo = SysInfo::instance(pTManager);
sysInfo->activate(THR_NEW_LWP | THR_JOINABLE);
// hash key 로그 작성을 위한 초기화.
HashKey::prepare();
// 로그 화일을 먼저 만들어 놓는다. 테스트시에 편하다. (tail -f )
PasDataLog::instance();
// accept event 핸들러 등록
pReactor->register_handler(pAcceptor, ACE_Event_Handler::ACCEPT_MASK);
// 이벤트 디멀티플렉싱
PAS_NOTICE("Master Reactor Start");
pReactor->run_event_loop();
PAS_NOTICE("Master Reactor Stop");
ReactorPool::instance()->stopWorkers();
/*--- Reactor 가 종료된 경우 아래 라인으로 진행된다. ---*/
stopACL(); // ACL 종료
userInfoMng->stop();
monitor->stop();
watch->stop();
phoneTraceMng->putq(new ACE_Message_Block());
statFilterMng->putq(new ACE_Message_Block());
sysInfo->putq(new ACE_Message_Block());
authAgent->putq(new ACE_Message_Block());
DNS::Manager::instance()->removeAllQuerier();
// 모든 쓰레드 종료 대기
PAS_NOTICE("Waiting for all threads to stop");
pTManager->wait();
delete phoneTraceMng;
delete statFilterMng;
delete sysInfo;
// 생성한 동적 객체 삭제
delete pSignalHandler;
PAS_NOTICE("======= PAS GW Stop =======");
return 0;
}
