Example #1
0
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;
}
Example #2
0
// 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;
}
Example #3
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;
}
Example #4
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;
}
Example #5
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;
}
Example #6
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;
}
Example #7
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;
}