base

rcts/rc_rmcd/src/CacheControl.cpp

@@ -0,0 +1,152 @@
+#include "CacheControl.h"
+
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <list>
+
+#include "CacheThread.h"
+#include "Logger.h"
+#include "ServiceConfig.h"
+
+// 매 Loop 마다 Sleep 시간 정보 정의 ( sec 단위)
+#define DEFAULT_SLEEP_TIME  2
+#define MAX_SLEEP_TIME      5
+
+
+CCacheControl::CCacheControl( CProcessStatus* pProcessStatus, CCacheJobList* pJobList, CDataQueue<CCacheData>* pQueueCacheComplete )
+	: m_pProcessStatus( pProcessStatus )
+	, m_pCacheJob( pJobList )
+	, m_pQueueCacheComplete( pQueueCacheComplete )
+{
+	// 멤버 변수 초기화
+	m_threadHandle = 0;
+
+	m_uSleep = DEFAULT_SLEEP_TIME;
+
+}
+
+CCacheControl::~CCacheControl()
+{
+	// Thread 동작 정지 처리
+	// - 만약 Thread 가 이미 종료된 경우 m_threadHandle 이 다른 Thread Handle 일 수 있으므로 
+	//   업무 Flow 수정시 주의할 것
+	if( m_threadHandle != 0 )
+		pthread_cancel( m_threadHandle );
+}
+
+// thread를 생성하여 Cache 생성 Thread 관련 작업을 수행.
+bool CCacheControl::Start()
+{
+	int nRet = ::pthread_create( &m_threadHandle, NULL, CCacheControl::threadFunc, this );
+	if( nRet != 0 )
+	{
+		// Thread 생성 실패시
+		int errorNum = errno;
+		LOG( LERR, "Thread create failed.[%d][%s]", errorNum, strerror( errorNum ) );
+
+		return false;
+	}
+
+	return true;
+}
+
+void* CCacheControl::threadFunc( void* arg )
+{
+	CCacheControl* pObject = reinterpret_cast<CCacheControl *>( arg );
+	pthread_detach( pthread_self() );
+
+	while( 1 )
+	{
+		pthread_testcancel();
+		pObject->Execute();
+		pthread_testcancel();
+
+		// 요청에 대한 처리속도와 연관된다.
+		sleep( pObject->m_uSleep );
+	}
+
+	// NEW 2014 - 06 - 23 huibong
+	// Thread 종료시 m_threadHandle 값을 초기화 처리.
+	// - 소멸자에서 잘못된 Thread 를 종료할 수 있기 때문.
+	pObject->m_threadHandle = 0;
+
+	return NULL;	
+}
+
+// 스레드 내에서 각 loop 단위 처리 호출 함수.
+void CCacheControl::Execute()
+{
+	if( MakeCache() == true )
+	{
+		m_uSleep = DEFAULT_SLEEP_TIME;
+	}
+	else
+	{
+		m_uSleep = MAX_SLEEP_TIME;
+	}
+}
+
+
+// 스레드 내에서 각 loop 단위 처리 호출 함수.
+// return true  : 처리할 Data 가 계속 존재하는 경우...
+//        false : 처리할 Data 가 없어 idle 한 경우.
+bool CCacheControl::MakeCache()
+{
+	// 1. CProcessStatus에서 생성 가능한 Cache Thread  수 확인
+	unsigned int nWorkCount = 0;
+	nWorkCount = m_pProcessStatus->GetValidCacheCount();
+	if( nWorkCount == 0 )
+	{
+		// 생성 가능한 Cache Thrad 수가 없는 경우...
+		// - false 를 반환할 경우... MAX_SLEEP_TIME 만큼 대기하므로... 
+		// - 빠른 시간내에 재시도할 수 있도록 true 를 반환.
+		return true;
+	}
+	
+	// 2. Job 정보를 가져온다.
+	// - 생성 가능한 Cache Thread 수 만큼 Job 을 가져온다.
+	std::list<CCacheData> listWork;
+	if( m_pCacheJob->GetDataToStart( nWorkCount, listWork ) == false )
+	{
+		// 진행할 Cache Job 이 없는 경우.
+		// - idle 상태
+		return false;
+	}
+
+	// 3. 가져온 Job 만큼 Cache Thread 를 생성한다.
+	CCacheData dataCache;
+	while( listWork.empty() == false )
+	{
+		// List 상의 항목을 POP 처리
+		dataCache = listWork.front();
+		listWork.pop_front();
+		
+		// CCacheThread 생성.
+		// - 이 곳에서는 new로 할당만 한다.
+		// - CCacheThread가 종료될때 delete this를 하기때문이니 놀라지말것.
+		CCacheThread* pCacheThread = new CCacheThread( m_pProcessStatus, m_pCacheJob, m_pQueueCacheComplete, dataCache );
+
+		// Thread 생성 또는 기동 실패시
+		// - 해당 Cache 요청을 삭제 처리한다.		
+		if( pCacheThread == NULL || pCacheThread->Start() == false )
+		{
+			// 최종 Thread 정리
+			if( pCacheThread != NULL )
+			{
+				delete pCacheThread;
+				pCacheThread = NULL;
+			}
+
+			_LOG( LERR, "CCacheControl: cache thread start fail.[%s][%s]"
+				, dataCache.m_requestData.m_strRequestHost.c_str()
+				, dataCache.m_requestData.m_strFileNameHash.c_str() );
+
+			// Job 항목에서 삭제 처리한다.
+			m_pCacheJob->UnRegister( dataCache );			
+		}
+	}
+
+	// 처리가 완료된 경우.
+	return true;
+}

rcts/rc_rmcd/src/CacheControl.h

@@ -0,0 +1,83 @@
+/***************************************************************************
+                Cache create Control class
+                -----------------------------------------
+    begin      : 2010/03/31
+    copyright  : (C) 2010 Solbox Inc.
+    author     : storage dev team
+    email      : storage.sd@solbox.com
+    version    : 3.3
+
+    CopyRight(C) 2010 Solbox Inc. All Rights reserved.
+    Redistribution and use in source and binary forms, with or with out
+    modification, are not permitted in outside of Solbox Inc.
+***************************************************************************/
+
+#ifndef __CACHE_CONTROL_H__
+#define __CACHE_CONTROL_H__
+
+#include <pthread.h>
+
+#include "ProcessStatus.h"
+#include "CacheData.h"
+#include "CacheJobList.h"
+#include "DataQueue.hpp"
+
+
+// CCacheControl
+// Cache Job List 의 정보를 바탕으로 실제 Cache 를 생성하는 Thread 를 
+// 생성하는 역활을 수행,
+// 전체적으로 Cache 생성 업무 Flow 를 제어한다.
+// 내부적으로 Thread를 사용하고있다. 
+class CCacheControl
+{
+    public:
+
+        // 생성자
+		CCacheControl( CProcessStatus* pProcessStatus, CCacheJobList* pJobList, CDataQueue<CCacheData>* pQueueCacheComplete );
+		        
+		// 소멸자
+		~CCacheControl();
+        
+		// thread를 생성하여 Cache 생성 Thread 관련 작업을 수행.
+		bool Start();
+        
+        
+    private:
+        
+		// 프로세스 상의 Queue, Thread 상태를 관리하는 CProcessStatus 객체에 대한 포인터
+		// - 생성자를 통해 전달받음        
+		CProcessStatus * m_pProcessStatus;
+
+		// Cache 생성 관련 Job List 객체에 대한 포인터
+		// - 생성자를 통해 전달받음
+		CCacheJobList* m_pCacheJob;
+
+		// Cache 생성 완료 저장 Queue 에 대한 포인터
+		// - 생성자를 통해 전달받음
+		CDataQueue<CCacheData>* m_pQueueCacheComplete;
+		
+        
+        // 쓰레드 핸들
+        pthread_t m_threadHandle;
+
+		// Thread Loop 마다 Sleep Time 정보를 저장하기 위한 변수
+		unsigned int m_uSleep;
+    
+
+	private:
+
+		// 스레드 함수
+		static void* threadFunc( void* arg );
+
+		// 스레드 내에서 각 loop 단위 처리 호출 함수.
+		void Execute();
+		
+
+		// 스레드 내에서 각 loop 단위 처리 호출 함수.
+		// return true  : 처리할 Data 가 계속 존재하는 경우...
+		//        false : 처리할 Data 가 없어 idle 한 경우.
+		bool MakeCache();
+
+};
+
+#endif //__CACHE_CONTROL_H__

rcts/rc_rmcd/src/CacheData.cpp

@@ -0,0 +1,54 @@
+#include "CacheData.h"
+
+// Cache Job 상태 정보 선언
+// Cache 대기 상태
+#define CACHE_STATUS_READY   0
+// Cache Thread 가 할당되어 생성 작업 중인 상태
+#define CACHE_STATUS_START   1
+
+
+// 생성자
+CCacheData::CCacheData()
+{
+	m_nStatus = CACHE_STATUS_READY;	
+}
+
+// 소멸자
+CCacheData::~CCacheData()
+{
+
+}
+
+// 본 객체의 재사용을 위한 멤버 변수 초기화 함수
+void CCacheData::Init()
+{
+	m_requestData.Init();
+
+	//m_strUri.clear();
+
+	m_strSourceHost.clear();
+	m_strSourceFilenameHash.clear();
+
+	m_strTargetHost.clear();
+	m_strTargetFilenameHash.clear();
+
+	m_nStatus = CACHE_STATUS_READY;
+}
+
+void CCacheData::SetStatusReady()
+{
+	m_nStatus = CACHE_STATUS_READY;
+}
+
+void CCacheData::SetStatusStart()
+{
+	m_nStatus = CACHE_STATUS_START;
+}
+
+bool CCacheData::IsStatusReady()
+{
+	if( m_nStatus == CACHE_STATUS_READY )
+		return true;
+	else
+		return false;
+}

rcts/rc_rmcd/src/CacheData.h

@@ -0,0 +1,88 @@
+/***************************************************************************
+                Cache 관련 Data 정보 저장 Class
+                -----------------------------------------
+    begin      : 2014/07/08
+    copyright  : (C) 2005 Solbox Inc.
+    author     : Storage Dev Team
+    email      : storage.sd@solbox.com
+    version    : 3.3
+
+    CopyRight(C) 2005 Solbox Inc. All Rights reserved.
+    Redistribution and use in source and binary forms, with or with out
+    modification, are not permitted in outside of Solbox Inc.
+***************************************************************************/
+
+#ifndef __CACHE_DATA_H__ 
+#define __CACHE_DATA_H__
+
+#include <string>
+
+#include "CacheRequestData.h"
+
+
+// CCacheData
+// Cache 생성 관련 Content 에 대한 모든 정보를 관리하는 Data 객체
+class CCacheData
+{
+    public:
+
+		// 생성자
+		CCacheData();
+
+		// 소멸자
+		~CCacheData();
+
+		// 본 객체의 재사용을 위한 멤버 변수 초기화 함수
+		void Init( void );
+
+		// 해당 Content 의 작업 상태 정보 변경
+		// - Cache 생성 대기 상태로 변경
+		void SetStatusReady();
+
+		// 해당 Content 의 작업 상태 정보 변경
+		// - Cache 생성 작업 중 상태로 변경
+		void SetStatusStart();
+
+		// 해당 Content 의 작업 상태가 CACHE_STATUS_READY 여부 판단
+		bool IsStatusReady();
+
+
+	public:
+
+		// FHS 로 부터 수신된 Cache 생성 request 정보 저장 객체
+		// - FHS 수신 관련 Worker 및 FimngdSocketControl 모듈에서 data 생성 처리
+		CCacheRequestData m_requestData;
+
+		// FHS 로 부터 수신된 요청의 uri 정보
+		// - COPY 로 인해 물리 Content 에 연결된 URI 가 여러개인 경우 발생.
+		// - 따라서 단순 로깅 목적으로의 URI 정보 표시시 오해 발생 가능하므로...
+		// - URI 정보는 사용하지 않토록 수정함.
+		//std::string m_strUri;
+		
+		// Cache 생성 작업시 원본 Content 를 제공할 FHS 정보
+		// - CacheOrder 모듈에서 생성
+		std::string m_strSourceHost;
+
+		// Cache 생성 작업시 원본 Content 의 filename hash 정보
+		// - CacheOrder 모듈에서 생성
+		std::string m_strSourceFilenameHash;
+
+		// Cache 생성 작업시 Cache Content 를 저장할 FHS 정보
+		// - CacheOrder 모듈에서 생성
+		std::string m_strTargetHost;
+				
+		// Cache 생성 작업을 통해 최종 생성된 filename hash 정보
+		// - Cache Thread 모듈에 의해 생성됨
+		std::string m_strTargetFilenameHash;
+
+
+	private:
+
+		// Cache 생성 작업 상태 정보 저장
+		// 0 : READY ( Thread 할당 대기 )
+		// 1 : START ( Thread 작업 중 )
+		int m_nStatus;
+												
+};
+
+#endif // __CACHE_DATA_H__

rcts/rc_rmcd/src/CacheDelete.cpp

@@ -0,0 +1,368 @@
+#include "CacheDelete.h"
+
+#include <errno.h>
+#include <string.h>
+
+#include "Logger.h"
+#include "Database.h"
+#include "Util.h"
+#include "ServiceConfig.h"
+
+
+// Query 문장 저장을 위한 Buffer 크기
+#define DEFAULT_QUERY_BUFFER_SIZE 512
+
+// sec 를 micro-sec 로 단위 변환시 환산 계수.
+#define SEC_TO_MICROSEC          (1000000LL)
+
+// 삭제 작업시 시작 시간을 설정하기 위한 보정값.
+#define CACHE_DELETE_RANGE	            (60*60*48)  // 48시간
+
+// 삭제 주기 ( sec 단위)
+#define CAHCE_DEL_CHECK_TERM_SEC		(20 * 60)   // 20분
+
+
+// 생성자
+CCacheDelete::CCacheDelete()	
+{
+	m_threadHandle = 0;
+
+	// NEW 2014-06-16 신규 멤버 변수 초기화 코드 추가.
+	// Init() 에서 RCDB 접속 실패가 발생 가능하므로.. 구형 RCDB 형상을 사용토록 설정.
+	m_bServiceTableSeparate = false;
+}
+
+// 소멸자
+CCacheDelete::~CCacheDelete()
+{
+	// Thread 동작 정지 처리
+	// - 만약 Thread 가 이미 종료된 경우 m_threadHandle 이 다른 Thread Handle 일 수 있으므로 
+	//   업무 Flow 수정시 주의할 것
+	if( m_threadHandle != 0 )
+		pthread_cancel( m_threadHandle );    
+}
+
+// 객체 초기화 수행
+bool CCacheDelete::Init()
+{
+	// RCDB 접속 정보 Load.
+	m_rcdbInfo.Load();
+
+	// RCDB 접속 처리를 위한 객체 생성
+	DataBase rcdb;
+
+	// RCDB 접속 시도 및 접속 실패시
+	if( rcdb.PgOpenDB( m_rcdbInfo.m_strRcdbIp, m_rcdbInfo.m_nRcdbPort
+		, m_rcdbInfo.m_strRcdbName, m_rcdbInfo.m_strRcdbAcct
+		, m_rcdbInfo.m_strRcdbAcctPw ) == NULL )
+	{
+		LOG( LERR, "RCDB connection failed." );
+		return false;
+	}
+	else
+	{
+		// 접속 성공한 경우...
+		LOG( LINF, "RCDB connection test ok..." );
+
+		// NEW 2014-06-23 huibong
+		// 서비스 table 분리된 신규 형상인지.. 구형 형상인지 체크하여
+		// m_bServiceTableSeparate 변수 설정 처리.
+		// 해당 변수 초기화는 생성자에서 1차로 수행함.
+		char szQuery[1024];
+		snprintf( szQuery, 1023,
+			"SELECT * FROM pg_tables WHERE schemaname = 'public' AND tablename = 't_dav_resource' " );
+
+		rcdb.PgDoExec( szQuery );
+		if( rcdb.PgResult( DataBase::NOT_CLEAR ) < 0 )
+		{
+			// Query 수행 결과 오류 발생시...
+			// - pg_tables 가 존재하지 않을 경우 오류 발생 가능...
+			// - 이는 RCDB 가 아직 적절하게 구성되지 않았다는 의미이므로... Init()함수를 오류로 처리한다.
+			LOG( LERR, "RCDB t_dav_resource exist check failed.[%s][%s]", rcdb.GetErrorMessage().c_str(), szQuery );
+
+			rcdb.PgClear();
+			rcdb.PgCloseDB();
+
+			return false;
+		}
+		else
+		{
+			// Query 수행이 정상인 경우.
+			int  nResult = rcdb.GetNoTuples();
+			if( nResult > 0 )
+			{
+				// t_dav_resource 테이블이 존재하는 경우...
+				m_bServiceTableSeparate = false;
+				_LOG( LINF, "CCacheDelete: t_dav_resource table exist.[Old RCDB Type]" );
+			}
+			else
+			{
+				// t_dav_resource 테이블이 존재하지 않는 서비스별 테이블 분리 형상인 경우.
+				m_bServiceTableSeparate = true;
+				_LOG( LINF, "CCacheDelete: t_dav_resource table not exist.[New RCDB Type]" );
+			}
+		}
+
+		// RCDB 조회 결과 set 를 clear 처리 후 RCDB 접속 해제.
+		rcdb.PgClear();
+		rcdb.PgCloseDB();
+
+		return true;
+	}
+}
+
+// thread를 생성하여 업무 flow 를 시작.
+bool CCacheDelete::Start()
+{
+	int nRet = ::pthread_create( &m_threadHandle, NULL, CCacheDelete::threadFunc, this );
+	if( nRet != 0 )
+	{
+		// Thread 생성 실패시
+		int errorNum = errno;
+		LOG( LERR, "Thread create failed.[%d][%s]", errorNum, strerror( errorNum ) );
+
+		return false;
+	}
+
+	return true;
+}
+
+void * CCacheDelete::threadFunc( void * arg )
+{
+	CCacheDelete* pObject = reinterpret_cast<CCacheDelete *>( arg );
+	pthread_detach( pthread_self() );
+
+	while( 1 )
+	{
+		pthread_testcancel();
+		pObject->Execute();
+		pthread_testcancel();
+
+		sleep( CAHCE_DEL_CHECK_TERM_SEC );
+	}
+
+	// NEW 2014-06-23 huibong
+	// Thread 종료시 m_threadHandle 값을 초기화 처리.
+	// - 소멸자에서 잘못된 Thread 를 종료할 수 있기 때문.
+	pObject->m_threadHandle = 0;
+
+	// CHG 2014-06-23 huibong
+	// detach 된 Thread 에 대해 pthread_exit() 호출시
+	// 기준 할당 자원에 대한 해지 처리가 되지 않아 메모리 누수 발생 가능( FreeBSD ftsd 발생)
+	// 따라서 이를 해결하기 detach 된 thread 에 대해 pthread_exit() 호출 코드 제거.
+	//pthread_exit(NULL);
+	return NULL;
+}
+
+// 스레드 내에서 각 loop 단위 처리 호출 함수.
+void CCacheDelete::Execute()
+{
+	// 구형 t_dav_resource 테이블 사용시
+	if( m_bServiceTableSeparate == false )
+	{
+		DeleteFromOldDB();
+	}
+	else
+	{
+		// 신형 RCDB 형상 사용시
+		DeleteFromDB();
+	}
+}
+
+
+// RCDB t_dav_resource 테이블에서 유효기간이 지난 Hot Content Cache Content 를 삭제 처리
+// - 구형 RCDB 지원 목적
+bool CCacheDelete::DeleteFromOldDB()
+{
+	// 1. 현재 시간정보를 구한다.( micro-second 단위)
+	long long timeNow = longtime_now();
+	if( timeNow < 0 )
+	{
+		LOG( LERR, "longtime_now function error [%lld]", timeNow );
+		return false;
+	}
+
+	// 2. RCDB 와 연결 처리.
+	DataBase rcdb;
+	if( rcdb.PgOpenDB( m_rcdbInfo.m_strRcdbIp, m_rcdbInfo.m_nRcdbPort
+		, m_rcdbInfo.m_strRcdbName, m_rcdbInfo.m_strRcdbAcct
+		, m_rcdbInfo.m_strRcdbAcctPw ) == NULL )
+	{
+		// RCDB 접속 실패시
+		LOG( LERR, "RCDB connection failed." );		
+		return false;
+	}
+
+	// 3. t_dav_resource 테이블에서 유효기간이 지난 Cache Content 를 삭제 상태로 update 처리
+
+	// Query 문장 저장을 위한 버퍼 생성
+	char szQuery[DEFAULT_QUERY_BUFFER_SIZE];
+	int nResult = 0;
+
+	// 처리 대상 시간 구간 계산 (micro-second 단위 )
+	long long timeStart;
+	long long timeEnd;
+
+	// 현재시간 기준으로 Hot Content Cache 의 보존 만료 시간을 계산.
+	timeEnd = timeNow - ( CServiceConfig::GetInstance()->GetCacheFileTimeout() * SEC_TO_MICROSEC );
+
+	// 조회 시작 시간을 계산.
+	// - 본 값이 없을 경우... RCDB를 Full Scan 해야 하므로.. RCDB 에 부하 발생 가능.
+	// - 따라서 보존 만료 시간 이전 48 시간 정도로 조회 범위를 감소시킨다.
+	timeStart = timeNow - ( ( CServiceConfig::GetInstance()->GetCacheFileTimeout() + CACHE_DELETE_RANGE ) * SEC_TO_MICROSEC );
+			
+	snprintf(szQuery, DEFAULT_QUERY_BUFFER_SIZE - 1,
+			"UPDATE t_dav_resource SET deleted_yn = 'Y' ,get_lastmodified = %lld "
+			"WHERE is_cache = 'Y' AND deleted_yn = 'N' "
+			  "AND get_lastmodified >= '%lld' "
+			  "AND get_lastmodified <= '%lld';"
+			, timeNow, timeStart, timeEnd
+			);
+    
+	// Query 실행 
+	rcdb.PgDoExec(szQuery);
+
+	// Update 처리 결과 Row 수 확인.
+	nResult = rcdb.GetCmdTuples();
+
+	if( nResult > 0 )
+	{
+		_LOG( LINF, "CCacheDelete: t_dav_resource delete count[%d]", nResult );
+	}
+
+	rcdb.PgClear();
+	rcdb.PgCloseDB();    
+	
+	return true;
+}
+
+// RCDB t_meta_xxx 테이블에서 유효기간이 지난 Hot Content Cache Content 를 삭제 처리        
+// - 신형 RCDB 지원 목적
+bool CCacheDelete::DeleteFromDB()
+{
+	// 1. 현재 시간정보를 구한다.( micro-second 단위)
+	long long timeNow = longtime_now();
+	if( timeNow < 0 )
+	{
+		LOG( LERR, "longtime_now function error [%lld]", timeNow );
+		return false;
+	}
+
+	// 2. RCDB 와 연결 처리.
+	DataBase rcdb;
+	if( rcdb.PgOpenDB( m_rcdbInfo.m_strRcdbIp, m_rcdbInfo.m_nRcdbPort
+		, m_rcdbInfo.m_strRcdbName, m_rcdbInfo.m_strRcdbAcct
+		, m_rcdbInfo.m_strRcdbAcctPw ) == NULL )
+	{
+		// RCDB 접속 실패시
+		LOG( LERR, "RCDB connection failed." );
+		return false;
+	}
+
+	// Query 문장 저장을 위한 버퍼 생성
+	char szQuery[DEFAULT_QUERY_BUFFER_SIZE];
+	int nResult = 0;
+
+
+	// 3. RCDB t_sms_sp_svc_product 테이블에 저장된 서비스 정보를 조회한다.
+	snprintf( szQuery, DEFAULT_QUERY_BUFFER_SIZE - 1,
+		     "SELECT sp_svc_tran_id FROM t_sms_sp_svc_product ORDER BY sp_svc_tran_id DESC "
+		    );
+
+	// Query 실행 
+	rcdb.PgDoExec( szQuery );
+	nResult = rcdb.PgResult( DataBase::NOT_CLEAR );
+	if( nResult < 0 )
+	{
+		// Query 오류 발생시
+		// - RCDB 연결 실패 또는
+		// - t_sms_sp_svc_product 테이블이 존재하지 않을 경우.		
+		LOG( LERR, "RCDB t_sms_sp_svc_product query error.[%s][%s]"
+			, rcdb.GetErrorMessage().c_str(), szQuery );
+
+		rcdb.PgClear();
+		rcdb.PgCloseDB();
+		
+		return false;
+	}
+
+	// 조회된 각 고객사 정보 확인
+	nResult = rcdb.GetNoTuples();
+	if( nResult <= 0 )
+	{
+		// 고객사가 존재하지 않는 경우
+		_LOG( LINF, "CCacheDelete: service not found from t_sms_sp_svc_product.[%d]"
+			, nResult );
+
+		rcdb.PgClear();
+		rcdb.PgCloseDB();
+		return true;
+	}
+
+	// 조회된 고객사 정보를 변수에 저장.
+	std::vector<std::string> vecService;
+	std::string strTemp;
+	for( int i = 0; i < nResult; i++ )
+	{
+		strTemp = rcdb.GetValue( i, 0 );		
+		if( strTemp.size() > 0 )
+			vecService.push_back( strTemp );		
+	}
+	
+	rcdb.PgClear();
+
+	// 변수에 저장된 서비스 정보의 수를 최종 확인
+	if( vecService.empty() == true )
+	{
+		// 유효한 서비스 정보가 존재하지 않는 경우.
+		_LOG( LINF, "CCacheDelete: service not found from t_sms_sp_svc_product." );
+		rcdb.PgCloseDB();
+		return true;
+	}
+		
+	// 4. 루프를 돌면서 
+	// 각 서비스별 t_meta_xx 테이블에서 유효기간이 지난 Cache Content 를 삭제 상태로 update 처리
+	
+	// 처리 대상 시간 구간 계산 (micro-second 단위 )
+	long long timeStart;
+	long long timeEnd;
+
+	// 현재시간 기준으로 Hot Content Cache 의 보존 만료 시간을 계산.
+	timeEnd = timeNow - ( CServiceConfig::GetInstance()->GetCacheFileTimeout() * SEC_TO_MICROSEC );
+
+	// 조회 시작 시간을 계산.
+	// - 본 값이 없을 경우... RCDB를 Full Scan 해야 하므로.. RCDB 에 부하 발생 가능.
+	// - 따라서 보존 만료 시간 이전 48 시간 정도로 조회 범위를 감소시킨다.
+	timeStart = timeNow - ( ( CServiceConfig::GetInstance()->GetCacheFileTimeout() + CACHE_DELETE_RANGE ) * SEC_TO_MICROSEC );
+
+	std::vector< std::string >::const_iterator it;
+	for( it = vecService.begin(); it != vecService.end(); ++it )	
+	{
+		snprintf( szQuery, DEFAULT_QUERY_BUFFER_SIZE - 1,
+			"UPDATE t_meta_%s SET deleted_yn = 'Y' ,get_lastmodified = %lld "
+			"WHERE is_cache = 'Y' AND deleted_yn = 'N' "
+			"AND get_lastmodified >= '%lld' "
+			"AND get_lastmodified <= '%lld';"
+			, it->c_str()
+			, timeNow, timeStart, timeEnd
+			);
+
+		// Query 실행 
+		rcdb.PgDoExec( szQuery );
+
+		// Update 처리 결과 Row 수 확인.
+		nResult = rcdb.GetCmdTuples();
+		if( nResult > 0 )
+		{
+			_LOG( LINF, "CCacheDelete: t_meta_%s delete count[%d]", it->c_str(), nResult );
+		}
+
+		rcdb.PgClear();
+	}
+
+	// 작업이 완료된 경우... RCDB 연결 해제.
+	rcdb.PgClear();
+	rcdb.PgCloseDB();
+
+	return true;
+}

rcts/rc_rmcd/src/CacheDelete.h

@@ -0,0 +1,76 @@
+/***************************************************************************
+                Cache content delete class
+                -----------------------------------------
+    begin      : 2010/03/11
+    copyright  : (C) 2010 Solbox Inc.
+    author     : storage dev team
+    email      : storage.sd@solbox.com
+    version    : 3.3
+
+    CopyRight(C) 2010 Solbox Inc. All Rights reserved.
+    Redistribution and use in source and binary forms, with or with out
+    modification, are not permitted in outside of Solbox Inc.
+***************************************************************************/
+
+
+#ifndef __CACHE_DELETE_H__
+#define __CACHE_DELETE_H__
+
+#include <pthread.h>
+
+#include "RcdbInfo.h"
+
+// CCacheDelete
+// RCDB 에 저장된 Hot Content Cache Content 의 Timeout 여부를 판단하여...
+// 설정된 유효 기간이 초과된 경우.. 삭제 처리를 수행한다.
+class CCacheDelete
+{
+    public :
+        // 생성자        
+		CCacheDelete();
+        
+		// 소멸자
+		~CCacheDelete();
+        
+        // 객체 초기화 수행
+        bool Init();
+        
+		// thread를 생성하여 업무 flow 를 시작.
+        bool Start();
+        
+
+	private :
+		
+		// 스레드 함수
+		static void* threadFunc( void* arg );
+
+		// 스레드 내에서 각 loop 단위 처리 호출 함수.
+		void Execute();
+        
+        // RCDB t_dav_resource 테이블에서 유효기간이 지난 Hot Content Cache Content 를 삭제 처리
+		// - 구형 RCDB 지원 목적
+		bool DeleteFromOldDB();
+
+		// RCDB t_meta_xxx 테이블에서 유효기간이 지난 Hot Content Cache Content 를 삭제 처리        
+		// - 신형 RCDB 지원 목적
+		bool DeleteFromDB();
+
+        
+	private :        
+		
+    	// 내부 Thread 에 대한 ID
+        pthread_t m_threadHandle;
+
+		// RCDB 접속 정보를 저장할 변수.
+		CRcdbInfo m_rcdbInfo;
+
+		// New 2014-06-23 huibong
+		// RCDB 형상변경에 따라 서비스별 Table 분리 여부 판단 flag
+		// TODO: 향후 신규 RCDB 형상 적용 완료 후 본 항목 제거 필요.
+		// - false : 기존 t_dav_resource 테이블 사용.
+		// - ture  : 신규 RCDB 형상 (서비스별 meta table 분리) 사용.
+		bool m_bServiceTableSeparate;
+
+};
+
+#endif // __CACHE_DELETE_H__

rcts/rc_rmcd/src/CacheInsert.cpp

@@ -0,0 +1,581 @@
+#include "CacheInsert.h"
+
+#include <errno.h>
+#include <string.h>
+
+#include "Database.h"
+#include "Logger.h"
+#include "Util.h"
+
+
+// 처리 loop 간의 sleep time 정의
+#define DEFAULT_SLEEP_TIME  3
+// RCDB 접속 실패 또는 Query 실패 등의 상황 발생시 
+#define MAX_SLEEP_TIME     30
+
+// Query 문장 저장을 위한 Buffer 크기
+#define DEFAULT_QUERY_BUFFER_SIZE 2048
+
+
+// 생성자
+// param [IN] pQueueCacheComplete Cache 생성 완료 Queue 에 대한 포인터
+// param [IN] pListCacheJob Cache 생성 관련 Job List 객체에 대한 포인터
+CCacheInsert::CCacheInsert( CDataQueue<CCacheData>* pQueueCacheComplete, CCacheJobList* pCacheJob )
+	: m_pQueueCacheComplete( pQueueCacheComplete )
+	, m_pCacheJob( pCacheJob )
+	
+{
+	m_threadHandle = 0;
+
+	m_uSleep = DEFAULT_SLEEP_TIME;
+
+	// NEW 2014-07-07 신규 멤버 변수 초기화 코드 추가.
+	// Init() 에서 RCDB 접속 실패가 발생 가능하므로.. 구형 RCDB 형상을 사용토록 설정.
+	m_bServiceTableSeparate = false;
+	}
+
+// 소멸자
+CCacheInsert::~CCacheInsert()
+{
+	// Thread 동작 정지 처리
+	// - 만약 Thread 가 이미 종료된 경우 m_threadHandle 이 다른 Thread Handle 일 수 있으므로 
+	//   업무 Flow 수정시 주의할 것
+	if( m_threadHandle != 0 )
+		pthread_cancel( m_threadHandle );    
+}
+
+// 객체 초기화 수행
+bool CCacheInsert::Init()
+{
+	// 생성자로 전달받은 각 객체에 대한 포인터는 유효하다가 판단하고....
+	// 각 멤버변수에 대한 검사는 수행하지 않는다.
+
+	// RCDB 접속 정보 Load.
+	m_rcdbInfo.Load();
+
+	// RCDB 접속 처리를 위한 객체 생성
+	DataBase rcdb;
+
+	// RCDB 접속 시도 및 접속 실패시
+	if( rcdb.PgOpenDB( m_rcdbInfo.m_strRcdbIp, m_rcdbInfo.m_nRcdbPort
+		, m_rcdbInfo.m_strRcdbName, m_rcdbInfo.m_strRcdbAcct
+		, m_rcdbInfo.m_strRcdbAcctPw ) == NULL )
+	{
+		LOG( LERR, "RCDB connection failed." );
+		return false;
+	}
+	else
+	{
+		// 접속 성공한 경우...
+		LOG( LINF, "RCDB connection test ok..." );
+
+		// NEW 2014-06-23 huibong
+		// 서비스 table 분리된 신규 형상인지.. 구형 형상인지 체크하여
+		// m_bServiceTableSeparate 변수 설정 처리.
+		// 해당 변수 초기화는 생성자에서 1차로 수행함.
+		char szQuery[1024];
+		snprintf( szQuery, 1023,
+			"SELECT * FROM pg_tables WHERE schemaname = 'public' AND tablename = 't_dav_resource' " );
+
+		rcdb.PgDoExec( szQuery );
+		if( rcdb.PgResult( DataBase::NOT_CLEAR ) < 0 )
+		{
+			// Query 수행 결과 오류 발생시...
+			// - pg_tables 가 존재하지 않을 경우 오류 발생 가능...
+			// - 이는 RCDB 가 아직 적절하게 구성되지 않았다는 의미이므로... Init()함수를 오류로 처리한다.
+			LOG( LERR, "RCDB t_dav_resource exist check failed.[%s][%s]", rcdb.GetErrorMessage().c_str(), szQuery );
+
+			rcdb.PgClear();
+			rcdb.PgCloseDB();
+
+			return false;
+		}
+		else
+		{
+			// Query 수행이 정상인 경우.
+			int  nResult = rcdb.GetNoTuples();
+			if( nResult > 0 )
+			{
+				// t_dav_resource 테이블이 존재하는 경우...
+				m_bServiceTableSeparate = false;
+				_LOG( LINF, "CCacheInsert: t_dav_resource table exist.[Old RCDB Type]" );
+			}
+			else
+			{
+				// t_dav_resource 테이블이 존재하지 않는 서비스별 테이블 분리 형상인 경우.
+				m_bServiceTableSeparate = true;
+				_LOG( LINF, "CCacheInsert: t_dav_resource table not exist.[New RCDB Type]" );
+			}
+		}
+
+		// RCDB 조회 결과 set 를 clear 처리 후 RCDB 접속 해제.
+		rcdb.PgClear();
+		rcdb.PgCloseDB();
+
+		return true;
+	}	
+}
+
+// thread를 생성하여 업무 flow 를 시작.
+bool CCacheInsert::Start()
+{
+	int nRet = ::pthread_create( &m_threadHandle, 0, CCacheInsert::threadFunc, this );
+	if( nRet != 0 )
+	{
+		// Thread 생성 실패시
+		int errorNum = errno;
+		LOG( LERR, "Thread create failed.[%d][%s]", errorNum, strerror( errorNum ) );
+
+		return false;
+	}
+	
+	return true;
+}
+
+// 스레드 함수
+void* CCacheInsert::threadFunc( void* arg )
+{
+	CCacheInsert* pObject = reinterpret_cast<CCacheInsert *>( arg );
+	pthread_detach( pthread_self() );
+
+	while( 1 )
+	{
+		pthread_testcancel();
+		pObject->Execute();
+		pthread_testcancel();
+
+		// 1회 수행 후 지정된 시간 만큼 대기
+		sleep( pObject->m_uSleep );
+	}
+
+	// NEW 2014-07-07 huibong
+	// Thread 종료시 m_threadHandle 값을 초기화 처리.
+	// - 소멸자에서 잘못된 Thread 를 종료할 수 있기 때문.
+	pObject->m_threadHandle = 0;
+		
+	return NULL;
+}
+
+// 스레드 내에서 각 loop 단위 처리 호출 함수.
+void CCacheInsert::Execute()
+{
+	// Cache complete queue 상에 처리할 Data 가 존재하는 경우.
+	if( m_pQueueCacheComplete->GetSize() > 0 )
+	{
+		bool bResult;
+
+		// t_dav_resource 테이블 사용 형상인 경우.
+		if( m_bServiceTableSeparate == false )
+		{
+			bResult = InsertToOldDB();
+		}
+		else
+		{
+			// 서비스별 Table 이 분린된 신규 형상인 경우.
+			bResult = InsertToDB();
+		}
+				
+		// 처리 결과에 따라 loop sleep time 조정
+		if( bResult == true )
+			m_uSleep = DEFAULT_SLEEP_TIME;
+		else
+		{
+			// RCDB 연결 실패, Queury 수행 실패 등의 오류 발생시
+			m_uSleep = MAX_SLEEP_TIME;
+		}
+	}
+	else
+	{
+		// 처리할 Data 가 존재하지 않는 경우.
+		m_uSleep = DEFAULT_SLEEP_TIME;
+	}
+}
+
+// Cache 생성이 완료된 Job 내역을 구형 RCDB 형상에 INSERT 처리
+// - RCDB 에 저장이 완료된 후
+// - 해당 내역을 Job 관리 항목에서 삭제 처리해야 추가 요청을 수신할 수 있다.
+bool CCacheInsert::InsertToOldDB()
+{
+	// 1. RCDB 에 접속	
+	DataBase rcdb;
+	if( rcdb.PgOpenDB( m_rcdbInfo.m_strRcdbIp, m_rcdbInfo.m_nRcdbPort
+		, m_rcdbInfo.m_strRcdbName, m_rcdbInfo.m_strRcdbAcct
+		, m_rcdbInfo.m_strRcdbAcctPw ) == NULL )
+	{
+		// RCDB 접속이 실패
+		LOG( LERR, "RCDB connection failed." );
+		return false;
+	}
+	
+	// 2. Queue Pop 처리	
+	
+	// queue 에서 꺼낸 정보를 저장하기 위한 변수
+	CCacheData resultData;
+
+	// Query 문장 저장을 위한 버퍼 생성
+	char szQuery[DEFAULT_QUERY_BUFFER_SIZE];
+	
+	// Query 수행 결과값 저장을 위한 변수..	
+	int nResult = 0;
+
+	while( m_pQueueCacheComplete->GetSize() > 0 )	
+	{
+		// queue 에 저장된 첫번째 data 복사 (queue 에서 삭제된 상태 아님)		
+		resultData = m_pQueueCacheComplete->Front();
+
+		// 3. RCDB 에 저장된 해당 Content 의 원본 정보를 조회
+		//    - 이미 삭제가 되었을 수도 있지만....
+		//      RCDB 에 등록하지 않을 경우... 생성된 content 의 자동 삭제가 불가능하므로...
+		//      조회시 삭제 여부는 조건에 포함시키지 않는다.
+		//    - uri 정보를 이용하여 조회시 특수문자 포함으로 문제가 발생 가능하고..
+		//      실제 작업을 수행한 원본이 아닐 수 있으므로... (RCDB key 값 문제)
+		//      Source FHS 와 filname_hash 정보를 이용하여 조회 수행
+		sprintf( szQuery,
+			"SELECT "
+			" sp_user_seq, sp_svc_tran_id, '%s', "        // 생성된 FHS host_name
+			" resource_type, uri, filename_org, '%s', "   // 생성된 filename_hash
+			" depth, display_name, get_content_language,  "
+			" get_content_length, get_content_type, get_etag, "
+			" %lld, creation_date, "                      // get_lastmodified
+			" lock_discovery, source, supported_lock, deleted_yn, 'Y', file_lastmodified "
+			"FROM t_dav_resource "
+			"WHERE filename_hash = '%s' "                 // 생성시 사용한 filename_hash
+			"AND get_content_length = %lld "              // 생성시 사용한 get_content_length
+			"AND host_name = '%s' ;"                      // 생성시 사용한 FHS host_name
+			, resultData.m_strTargetHost.c_str()             // 생성된 FHS host_name
+			, resultData.m_strTargetFilenameHash.c_str()     // 생성된 filename_hash
+			, longtime_now()                                 // get_lastmodified
+			, resultData.m_strSourceFilenameHash.c_str()     // 생성시 사용한 filename_hash
+			, resultData.m_requestData.m_uContentLength      // 생성시 사용한 get_content_length
+			, resultData.m_strSourceHost.c_str()             // 생성시 사용한 FHS host_name
+			);
+
+		// Query 수행 및 결과 확인
+		rcdb.PgDoExec( szQuery );
+		nResult = rcdb.PgResult( DataBase::NOT_CLEAR );
+		if( nResult < 0 )
+		{
+			// RCDB t_dav_resource 테이블 조회 실패시
+			// 우선 DB 연결 문제일 수 있으므로... 
+			// RCDB 재접속 시도.
+			rcdb.PgClear();
+			rcdb.PgCloseDB();
+			sleep( 1 );
+
+			if( rcdb.PgOpenDB( m_rcdbInfo.m_strRcdbIp, m_rcdbInfo.m_nRcdbPort
+				, m_rcdbInfo.m_strRcdbName, m_rcdbInfo.m_strRcdbAcct
+				, m_rcdbInfo.m_strRcdbAcctPw ) == NULL )
+			{
+				// RCDB 접속 실패 문제인 경우..
+				// - 본 처리 함수 종료 처리하여 다음 loop 에서 재시도토록 처리.
+				LOG( LERR, "select query fail because RCDB connection error. [%d][%s]"
+					, nResult, rcdb.GetErrorMessage().c_str() );
+
+				rcdb.PgCloseDB();
+				return false;
+			}
+			else
+			{
+				// query 실패시				
+				// - 관련 내역 로깅
+				// - queue 에서 해당 정보를 삭제, Job 에서 해당 정보 삭제 후
+				// - 루프 계속 수행한다.
+				LOG( LERR, "select query fail. queue forced pop.[%d][%s][%s]"
+					, nResult, rcdb.GetErrorMessage().c_str(), szQuery );
+				
+				rcdb.PgClear();
+
+				m_pQueueCacheComplete->Pop();
+				m_pCacheJob->UnRegister( resultData );								
+				continue;
+			}
+		}
+
+		// 결과 Row 수 확인.
+		nResult = rcdb.GetNoTuples();
+		if( nResult <= 0 )
+		{
+			// Cache 생성된 content 가 RCDB 에 존재하지 않는 경우...
+			// - RCDB 에 저장하지 않고 그냥 버린다.
+			// - 이로 인해 FHS 에 meta 기준으로 삭제 불가능한 파일이 남게 된다.			
+			_LOG( LINF, "Cache source content[%s] not found in RCDB."
+				, resultData.m_strSourceFilenameHash.c_str() );
+
+			rcdb.PgClear();
+
+			m_pQueueCacheComplete->Pop();
+			m_pCacheJob->UnRegister( resultData );
+			continue;			
+		}
+
+		// 조회 결과는 
+		// COPY 처리로 인해 N 개의 URI 가 작업에 사용된 content 를 가르킬 수 있으므로...
+		// N 개가 조회 될 수 있다.
+		// 따라서 COPY 된 URI 각각에 대해 Cache 정보를 등록해야 한다.
+						
+		// 조회된 N개 row 정보를 저장하기 위한 vector
+		std::vector< std::vector<string> > srcarry;
+		std::string strResult;
+		for( int j = 0; j < nResult; j++ )
+		{
+			// 조회된 1개의 Row 정보를 저장하기 위한 vector
+			std::vector<string> srcinfo;
+			for( int k = 0; k < 21; k++ )
+			{
+				strResult = rcdb.GetValue( j, k );
+				strResult = stringreplace( strResult, "'", "''" );
+				srcinfo.push_back( strResult );
+			}
+
+			srcarry.push_back( srcinfo );
+		}
+		
+		// Select Query 의 결과를 Clear 
+		rcdb.PgClear();
+		
+		// 4. 조회된 N 개의 정보를 바탕으로 RCDB 에 INSERT 처리 수행.
+		while( srcarry.empty() == false )
+		{
+			std::vector<string> srcinfo = srcarry.back();
+			srcarry.pop_back();
+
+			sprintf( szQuery,
+				"INSERT INTO t_dav_resource "
+				"( "
+				"  sp_user_seq, sp_svc_tran_id, "
+				"  host_name, "
+				"  resource_type, uri, filename_org, filename_hash, "
+				"  depth, display_name, get_content_language, "
+				"  get_content_length, get_content_type, "
+				"  get_etag, get_lastmodified, creation_date, "
+				"  lock_discovery, source, supported_lock, deleted_yn, is_cache ,file_lastmodified) "
+				"VALUES "
+				" ( "
+				"  %s, %s, "
+				"  '%s', "
+				"  %s, '%s', '%s', '%s', "
+				"  %s, '%s', '%s', "
+				"  %s, '%s', "
+				"  '%s', %s, %s, "
+				"  '%s', %s, '%s', '%s', '%s', %s );", // is_cache = Y
+				srcinfo[0].c_str(), srcinfo[1].c_str(), srcinfo[2].c_str(), srcinfo[3].c_str(),
+				srcinfo[4].c_str(), srcinfo[5].c_str(), srcinfo[6].c_str(), srcinfo[7].c_str(),
+				srcinfo[8].c_str(), srcinfo[9].c_str(), srcinfo[10].c_str(), srcinfo[11].c_str(),
+				srcinfo[12].c_str(), srcinfo[13].c_str(), srcinfo[14].c_str(), srcinfo[15].c_str(),
+				srcinfo[16].c_str(), srcinfo[17].c_str(), srcinfo[18].c_str(), srcinfo[19].c_str(), srcinfo[20].c_str()
+				);
+
+			// INSERT query 수행
+			rcdb.PgDoExec( szQuery );
+			nResult = rcdb.PgResult( DataBase::CLEAR );
+			if( nResult < 0 )
+			{
+				// RCDB INSERT 작업시 오류가 발생한 경우...
+				// - DB 연결 문제 역시 바로 앞에서 체크 했으므로 아닐 가능성이 큼.
+				// - 가장 큰 오류는 Query 오류일 가능성이 큼.
+				// - 루프 계속 수행
+				
+				LOG( LERR, "insert query fail. queue forced pop.[%d][%s][%s]"
+					, nResult, rcdb.GetErrorMessage().c_str(), szQuery );				
+			}
+			else
+			{
+				// 성공시
+				// PgResult 호출시 CLEAR 옵션을 사용했으므로....내부 결과 set 포인터가 NULL 처리됨. 
+				// 따라서 수행 row 수 확인을 위해 GetCmdTuples() 함수를 호출해서는 안됨.
+
+				_LOG( LINF, "Cache insert to RCDB. query result[%d] [%s][%llu]"
+					, nResult, resultData.m_strTargetFilenameHash.c_str()
+					, resultData.m_requestData.m_uContentLength );
+			}
+			
+			// Query 재사용을 위한 clear 처리.
+			rcdb.PgClear();
+		}
+
+		// 5. 해당 Content 에 대한 작업이 완료된 경우..
+		// - Queue , Job 항목에서 삭제 처리.
+		m_pQueueCacheComplete->Pop();
+		m_pCacheJob->UnRegister( resultData );
+
+	}
+
+	// queue 에 저장된 정보 처리 작업이 완료된 경우...
+	// - RCDB 연결 해제 처리.
+	rcdb.PgClear();
+	rcdb.PgCloseDB();
+	
+	return true;
+}
+
+
+// Cache 생성이 완료된 Job 내역을 신규 RCDB 형상에 INSERT 처리
+// - RCDB 에 저장이 완료된 후
+// - 해당 내역을 Job 관리 항목에서 삭제 처리해야 추가 요청을 수신할 수 있다.
+bool CCacheInsert::InsertToDB()
+{
+	// 1. RCDB 에 접속	
+	DataBase rcdb;
+	if( rcdb.PgOpenDB( m_rcdbInfo.m_strRcdbIp, m_rcdbInfo.m_nRcdbPort
+		, m_rcdbInfo.m_strRcdbName, m_rcdbInfo.m_strRcdbAcct
+		, m_rcdbInfo.m_strRcdbAcctPw ) == NULL )
+	{
+		// RCDB 접속이 실패
+		LOG( LERR, "RCDB connection failed." );
+		return false;
+	}
+
+	// 2. Queue Pop 처리
+	
+
+	// queue 에서 꺼낸 정보를 저장하기 위한 변수
+	CCacheData resultData;
+
+	// Query 문장 저장을 위한 버퍼 생성
+	char szQuery[DEFAULT_QUERY_BUFFER_SIZE];
+
+	// Query 수행 결과값 저장을 위한 변수..	
+	int nResult = 0;
+
+	while( m_pQueueCacheComplete->GetSize() > 0 )	
+	{
+		// queue 에 저장된 첫번째 data 복사 (queue 에서 삭제된 상태 아님)		
+		resultData = m_pQueueCacheComplete->Front();
+
+		// 3. RCDB 에 저장된 해당 Content 의 원본 정보를 조회
+		//    - 이미 삭제가 되었을 수도 있지만....
+		//      RCDB 에 등록하지 않을 경우... 생성된 content 의 자동 삭제가 불가능하므로...
+		//      조회시 삭제 여부는 조건에 포함시키지 않는다.
+		//    - uri 정보를 이용하여 조회시 특수문자 포함으로 문제가 발생 가능하고..
+		//      실제 작업을 수행한 원본이 아닐 수 있으므로... (RCDB key 값 문제)
+		//      Source FHS 와 filname_hash 정보를 이용하여 조회 수행
+		//    - 신규 RCDB 형상 지원 및 미사용 컬럼 제거 처리
+
+		// CHG 2015-02-12 huibong 
+		// 신규 RCDB 형상에 맞도록 처리 Flow 단순화 (#21354)
+		// - RCDB 구조가 pgpool -> streaming replicaton 구조로 변경됨
+		// - 이에 따라 기존 SELECT 후 INSERT, 검수, DELETE flow 에 대한 단순화 가능함.
+		
+		sprintf( szQuery,
+				 "INSERT INTO t_meta_%s "
+				 "( "
+				 "  sp_user_seq, sp_svc_tran_id, host_name, "
+				 "  resource_type, uri, filename_org, filename_hash, "
+				 "  depth, display_name, "
+				 "  get_content_length, get_content_type, "
+				 "  get_lastmodified, creation_date, "
+				 "  source, deleted_yn, is_cache, file_lastmodified "
+				 ") "
+				 "SELECT "
+				 " sp_user_seq, sp_svc_tran_id, '%s', "               // 생성된 FHS host_name
+				 " resource_type, uri, filename_org, '%s', "          // 생성된 filename_hash
+				 " depth, display_name, "
+				 " get_content_length, get_content_type, "
+				 " %lld, creation_date, "                             // get_lastmodified
+				 " source, deleted_yn, 'Y', file_lastmodified "
+				 "FROM t_meta_%s "                                    // 신규 RCDB 형상
+				 "WHERE filename_hash = '%s' "                        // 생성시 사용한 filename_hash
+				 "AND get_content_length = %lld "                     // 생성시 사용한 get_content_length
+				 "AND host_name = '%s' ;"                             // 생성시 사용한 FHS host_name
+				 , resultData.m_requestData.m_strServiceSeq.c_str()   // 신규 RCDB 형상 지원
+				 , resultData.m_strTargetHost.c_str()                 // 생성된 FHS host_name
+				 , resultData.m_strTargetFilenameHash.c_str()         // 생성된 filename_hash
+				 , longtime_now()                                     // get_lastmodified
+				 , resultData.m_requestData.m_strServiceSeq.c_str()   // 신규 RCDB 형상 지원
+				 , resultData.m_strSourceFilenameHash.c_str()         // 생성시 사용한 filename_hash
+				 , resultData.m_requestData.m_uContentLength          // 생성시 사용한 get_content_length
+				 , resultData.m_strSourceHost.c_str()                 // 생성시 사용한 FHS host_name
+		);
+		
+		// Query 수행 및 결과 확인
+		rcdb.PgDoExec( szQuery );
+		nResult = rcdb.PgResult( DataBase::NOT_CLEAR );
+		if( nResult < 0 )
+		{
+			// Query 수행 실패시
+			// 우선 DB 연결 문제일 수 있으므로... 
+			// RCDB 재접속 시도.
+
+			std::string strPreviousErrorMessage = rcdb.GetErrorMessage();
+
+			rcdb.PgClear();
+			rcdb.PgCloseDB();
+			sleep( 1 );
+
+			if( rcdb.PgOpenDB( m_rcdbInfo.m_strRcdbIp, m_rcdbInfo.m_nRcdbPort
+				, m_rcdbInfo.m_strRcdbName, m_rcdbInfo.m_strRcdbAcct
+				, m_rcdbInfo.m_strRcdbAcctPw ) == NULL )
+			{
+				// RCDB 접속 실패 문제인 경우..
+				// - 본 처리 함수 종료 처리하여 다음 loop 에서 재시도토록 처리.
+				LOG( LERR, "Query fail because RCDB connection error. [%d][%s]"
+					, nResult, rcdb.GetErrorMessage().c_str() );
+
+				rcdb.PgCloseDB();
+				return false;
+			}
+			else
+			{
+				// query 실패시				
+				// - 관련 내역 로깅
+				// - queue 에서 해당 정보를 삭제, Job 에서 해당 정보 삭제 후
+				// - 루프 계속 수행한다.
+				LOG( LERR, "insert-select query fail. queue forced pop.[%d][%s][%s]"
+					 , nResult, strPreviousErrorMessage.c_str(), szQuery );
+
+				rcdb.PgClear();
+
+				m_pQueueCacheComplete->Pop();
+				m_pCacheJob->UnRegister( resultData );
+				continue;
+			}
+		}
+
+		// PgResult 호출시 NOT_CLEAR 옵션을 사용했으므로....INSERT 수행 row 수 확인을 위해 GetCmdTuples() 함수를 호출가능.
+		nResult = rcdb.GetCmdTuples();
+		if( nResult > 0 )
+		{
+			// COPY 처리로 인해 N 개의 URI 가 작업에 사용된 content 를 가르킬 수 있으므로...
+			// N 개가 나타날 수 있다.
+			
+			_LOG( LINF, "Cache insert to RCDB. [%d] row. [%s][%s][%llu]"
+				  , nResult
+				  , resultData.m_strTargetHost.c_str()
+				  , resultData.m_strTargetFilenameHash.c_str()
+				  , resultData.m_requestData.m_uContentLength 
+			);
+		}
+		else
+		{
+			// INSERT 처리된 row 가 없는 경우....
+			// - 생성된 cache 파일은 고아 파일이 됨.
+			
+			_LOG( LWAR, "cache rcdb Insert origin not found. orgin[%s|%s|%llu] orphan[%s|%s|%llu]"
+				  , resultData.m_strSourceHost.c_str()
+				  , resultData.m_strSourceFilenameHash.c_str()
+				  , resultData.m_requestData.m_uContentLength
+				  , resultData.m_strTargetHost.c_str()
+				  , resultData.m_strTargetFilenameHash.c_str()
+				  , resultData.m_requestData.m_uContentLength
+			);
+		}
+
+
+		// Query 의 결과 Clear 
+		rcdb.PgClear();
+
+
+		// 해당 Content 에 대한 작업이 완료된 경우..
+		// - Queue , Job 항목에서 삭제 처리.		
+		m_pQueueCacheComplete->Pop();
+		m_pCacheJob->UnRegister( resultData );
+				
+	}
+
+	// queue 에 저장된 정보 처리 작업이 완료된 경우...
+	// - RCDB 연결 해제 처리.
+	rcdb.PgClear();
+	rcdb.PgCloseDB();
+
+	return true;
+}

rcts/rc_rmcd/src/CacheInsert.h

@@ -0,0 +1,89 @@
+/***************************************************************************
+                생성된 Cache content 정보를 RCDB 에 저장처리
+                -----------------------------------------
+    begin      : 2010/03/11
+    copyright  : (C) 2010 Solbox Inc.
+    author     : storage dev team
+    email      : storage.sd@solbox.com
+    version    : 3.3
+
+    CopyRight(C) 2010 Solbox Inc. All Rights reserved.
+    Redistribution and use in source and binary forms, with or with out
+    modification, are not permitted in outside of Solbox Inc.
+***************************************************************************/
+
+#ifndef __CACHE_INSERT_H__
+#define __CACHE_INSERT_H__
+
+#include <pthread.h>
+
+#include "DataQueue.hpp"
+#include "CacheData.h"
+#include "CacheJobList.h"
+#include "RcdbInfo.h"
+
+
+// CCacheInsert
+// queue 에 저장된 Cache 생성이 완료된 Content 정보를 RCDB 에 INSERT 처리
+// 내부적으로 Thread를 사용
+class CCacheInsert
+{
+	public:
+		
+		// 생성자
+		// param [IN] pQueueCacheComplete Cache 생성 완료 Queue 에 대한 포인터
+		// param [IN] pListCacheJob Cache 생성 관련 Job List 객체에 대한 포인터		
+		CCacheInsert( CDataQueue<CCacheData>* pQueueCacheComplete, CCacheJobList* pCacheJob );
+		
+		// 소멸자
+		~CCacheInsert();
+
+		// 객체 초기화 수행
+		bool Init();
+
+		// thread를 생성하여 업무 flow 를 시작.
+		bool Start();
+
+	
+	private:
+
+		// Cache 생성 완료 저장 Queue 에 대한 포인터
+		// - 생성자를 통해 전달받음
+		CDataQueue<CCacheData>* m_pQueueCacheComplete;
+
+		// Cache 생성 관련 Job List 객체에 대한 포인터
+		// - 생성자를 통해 전달받음
+		CCacheJobList* m_pCacheJob;
+				
+		// 내부 Thread 에 대한 ID
+		pthread_t m_threadHandle;
+
+		// RCDB 접속 정보를 저장할 변수.
+		CRcdbInfo m_rcdbInfo;
+		
+		// New 2014-07-09 huibong
+		// RCDB 형상변경에 따라 서비스별 Table 분리 여부 판단 flag
+		// TODO: 향후 신규 RCDB 형상 적용 완료 후 본 항목 제거 필요.
+		// - false : 기존 t_dav_resource 테이블 사용.
+		// - ture  : 신규 RCDB 형상 (서비스별 meta table 분리) 사용.
+		bool m_bServiceTableSeparate;
+
+		// Thread Loop 마다 Sleep Time 정보를 저장하기 위한 변수
+		unsigned int m_uSleep;
+		
+	private:
+
+		// 스레드 함수
+		static void* threadFunc( void* arg );
+
+		// 스레드 내에서 각 loop 단위 처리 호출 함수.
+		void Execute();
+
+		// Cache 생성이 완료된 Job 내역을 구형 RCDB 형상에 INSERT 처리
+		bool InsertToOldDB();
+
+		// Cache 생성이 완료된 Job 내역을 신규 RCDB 형상에 INSERT 처리
+		bool InsertToDB();
+		
+};
+#endif // __CACHE_INSERT_H__ 

rcts/rc_rmcd/src/CacheJobList.cpp

@@ -0,0 +1,238 @@
+#include "CacheJobList.h"
+
+#include <stdio.h>
+
+#include "Logger.h"
+
+
+// 생성자
+CCacheJobList::CCacheJobList()
+{
+	pthread_mutex_init( &m_mutexMap, NULL );
+}
+
+// 소멸자
+CCacheJobList::~CCacheJobList()
+{
+	pthread_mutex_destroy( &m_mutexMap );
+}
+
+
+// 등록된 job 의 갯수 반환.
+unsigned int CCacheJobList::GetSize()
+{
+	return m_mapJob.size();
+}
+
+
+// 해당 Content 에 대한 Job 이 존재하는지 여부 판단.
+// true  : 이미 존재
+// false : 존재 안하거나.. 인자값 오류
+bool CCacheJobList::IsExist( CCacheRequestData & data )
+{
+	// 전달받은 정보를 이용하여 map 조회를 위한 key 값 생성
+	std::string strKey;
+	if( GetKey( data, strKey ) == false )
+	{
+		// Key 생성 실패시
+		return false;
+	}
+
+	// 생성된 Key 를 기준으로 존재 여부 확인
+	bool bResult;
+	std::map<std::string, CCacheData>::const_iterator pos;
+
+	// lock 처리 후 조회
+	pthread_mutex_lock( &m_mutexMap );
+
+	pos = m_mapJob.find( strKey );
+	if( pos != m_mapJob.end() )
+	{
+		// 해당 Key 값이 존재하면...
+		bResult = true;
+	}
+	else
+	{
+		// 해당 Key 값이 존재하지 않는 경우.
+		bResult = false;
+	}
+
+	// lock 해제
+	pthread_mutex_unlock( &m_mutexMap );
+
+	return bResult;
+}
+
+// 해당 Content 에 대해 등록된 job 삭제
+void CCacheJobList::UnRegister( CCacheData & data )
+{
+	// 전달받은 정보를 이용하여 map 조회를 위한 key 값 생성
+	std::string strKey;
+	if( GetKey( data.m_requestData, strKey ) == false )
+	{
+		// Key 생성 실패시
+		return;
+	}
+
+	// 생성된 Key 를 기준으로 존재 여부 확인	
+	std::map<std::string, CCacheData>::iterator pos;
+
+	// lock 처리 후 조회
+	pthread_mutex_lock( &m_mutexMap );
+
+	pos = m_mapJob.find( strKey );
+	if( pos != m_mapJob.end() )
+	{
+		// 해당 Key 값이 존재하면...erase 를 이용하여 삭제 처리
+		m_mapJob.erase( pos );		
+	}
+	
+	// lock 해제
+	pthread_mutex_unlock( &m_mutexMap );
+
+	return;
+}
+
+// 해당 Content 에 대한 Job 등록
+// true  : 등록 성공
+// false : 등록 실패
+bool CCacheJobList::Register( CCacheData & data )
+{
+	// 전달받은 정보를 이용하여 map 조회를 위한 key 값 생성
+	std::string strKey;
+	if( GetKey( data.m_requestData, strKey ) == false )
+	{
+		// Key 생성 실패시
+		return false;
+	}
+
+	// 생성된 Key 를 기준으로 존재 여부 확인
+	bool bResult;
+	std::map<std::string, CCacheData>::const_iterator pos;
+
+	// lock 처리 후 조회
+	pthread_mutex_lock( &m_mutexMap );
+
+	pos = m_mapJob.find( strKey );
+	if( pos != m_mapJob.end() )
+	{
+		// 해당 Key 값이 이미 존재하는 경우. 등록 실패 처리
+		bResult = false;
+	}
+	else
+	{
+		// 해당 정보가 존재하지 않는 경우.
+		// map 에 등록 처리.
+		if( m_mapJob.insert( std::pair<const std::string, CCacheData>( strKey, data ) ).second == false )
+		{
+			// insert 작업 실패시
+			bResult = false;
+		}
+		else
+		{
+			// insert 작업 성공시 
+			bResult = true;
+		}
+	}
+	
+	// lock 해제
+	pthread_mutex_unlock( &m_mutexMap );
+
+	// 처리 결과에 따른 로깅 처리
+	if( bResult == false )
+	{
+		LOG( LERR, "cache data insert fail to job [%s][%s]"
+				, data.m_requestData.m_strRequestHost.c_str()
+				, data.m_requestData.m_strFileNameHash.c_str() );		
+	}
+
+	return bResult;
+}
+
+// 저장된 job 중에서 상태 정보가 CACHE_STATUS_READY 인 job 을
+// 전달된 listData 에 최대 nMaxCount 값만큼 저장하여 반환한다.
+// - 전달된 job 은 중복 추출을 방지하기 위해 상태정보를 CACHE_STATUS_START 변경처리한다.
+// @param [IN] nMaxCout 추출 가능한 최대 갯수
+// @param [OUT] 추출된 job 정보를 저장하기 위한 List
+// @return false 추출 가능한 항목이 없을 경우.
+//         true  그 외
+bool CCacheJobList::GetDataToStart( const unsigned int nMaxCount, std::list<CCacheData>& listData )
+{
+	// 인자로 전달되어 저장 역활을 담당하는 listData 객체 초기화
+	listData.clear();
+	
+	// 전달받은 인자값 검사
+	if( nMaxCount == 0 )
+	{
+		LOG( LERR, "request job count 0. check flow [%u]", nMaxCount );
+		return false;
+	}
+	
+	std::map<std::string, CCacheData>::iterator it;
+
+	// lock 설정
+	pthread_mutex_lock( &m_mutexMap );
+
+	for( it = m_mapJob.begin(); it != m_mapJob.end(); ++it )
+	{
+		// CACHE_STATUS_READY 상태인지 확인
+		if( it->second.IsStatusReady() == true )
+		{
+			// 해당 job 의 상태를 CACHE_STATUS_START 로 변경 처리
+			it->second.SetStatusStart();
+
+			// 전달받은 listData 에 해당 정보 push 처리
+			listData.push_back( it->second );
+
+			// 요청한 갯수만큼 추출했는지 확인
+			if( listData.size() >= nMaxCount )
+				break;		
+		}
+	}
+	
+	// lock 해제
+	pthread_mutex_unlock( &m_mutexMap );
+
+	if( listData.empty() == true )
+		return false;
+	else
+		return true;
+}
+
+
+// 전달받은 정보를 바탕으로 map 에 사용할 Key 값을 생성한다.
+// key 값은 동일 Contnt 중복 방지를 위해
+// content_length:filename_hash(경로정보를 제외한 Only hash name) 형식으로 구성한다.
+// @param data [IN] content length 및 filename hash 정보가 저장된 CCacheRequestData 객체 참조
+// @param strKey [OUT] 생성된 key 값.
+bool CCacheJobList::GetKey( CCacheRequestData & data, std::string& strKey )
+{
+	// Key 값 생성을 위한 값에 대한 검사
+	if( data.m_uContentLength == 0 )
+	{
+		LOG( LERR, "invalid key parameter. length[%llu] hash[%s]"
+			, data.m_uContentLength, data.m_strFileNameHash.c_str());
+
+		return false;
+	}
+
+	std::string strHashName;
+	if( data.GetOnlyHashFileName( strHashName ) == false )
+	{
+		LOG( LERR, "invalid key parameter. hash[%s]"
+			,data.m_strFileNameHash.c_str() );
+
+		return false;
+	}
+	else
+	{
+		char tempBuffer[256];
+		sprintf( tempBuffer, "%llu", data.m_uContentLength );
+
+		strKey = tempBuffer;
+		strKey.append( ":" );
+		strKey.append( strHashName );
+
+		return true;
+	}
+}

rcts/rc_rmcd/src/CacheJobList.h

@@ -0,0 +1,93 @@
+/***************************************************************************
+                Cache 생성 관련 Job List 관리 class
+                -----------------------------------------
+    begin      : 2014/07/08
+    copyright  : (C) 2010 Solbox Inc.
+    author     : storage dev team
+    email      : storage.sd@solbox.com
+    version    : 3.3
+
+    CopyRight(C) 2010 Solbox Inc. All Rights reserved.
+    Redistribution and use in source and binary forms, with or with out
+    modification, are not permitted in outside of Solbox Inc.
+***************************************************************************/
+
+#ifndef __CACHE_JOB_LIST_H__
+#define __CACHE_JOB_LIST_H__
+
+#include <string>
+#include <map>
+#include <list>
+#include <pthread.h>
+
+#include "CacheRequestData.h"
+#include "CacheData.h"
+
+
+// CCacheJobList class
+// Hot Content cache 생성 관련하여 
+// 대기 중인 content 목록과 현재 Thread 를 통해서 진행 중인 Content 목록을 관리한다.
+// 본 클래스의 목적은 
+// 동일 Content 에 대해 연속된 Cache 생성 요청으로 인한 중복 작업으로 인해 발생 가능한 
+// 잘못된 업무 Flow 발생을 방지하기 위해 존재한다.
+// 작업 등록 : CacheOrder 모듈
+// 작업 수행 : CacheControl 모듈 및 각 Cache Thread
+// 작업 삭제 : CacheInsert 모듈에서 RCDB 작업 완료 후 삭제 처리.
+class CCacheJobList
+{
+	public :
+		
+		// 생성자.
+		CCacheJobList();
+		
+		// 소멸자.
+		~CCacheJobList();
+				
+		// 등록된 job 의 갯수 반환.
+		unsigned int GetSize( void );
+
+		// 해당 Content 에 대한 Job 이 존재하는지 여부 판단.
+		// true  : 이미 존재
+		// false : 존재 안하거나.. 인자값 오류
+		bool IsExist( CCacheRequestData & data );
+
+		// 해당 Content 에 대한 Job 등록
+		// true  : 등록 성공
+		// false : 등록 실패
+		bool Register( CCacheData & data );
+
+		// 해당 Content 에 대해 등록된 job 삭제
+		void UnRegister( CCacheData & data );
+		
+		// 저장된 job 중에서 상태 정보가 CACHE_STATUS_READY 인 job 을
+		// 전달된 listData 에 최대 nMaxCount 값만큼 저장하여 반환한다.
+		// - 전달된 job 은 중복 추출을 방지하기 위해 상태정보를 CACHE_STATUS_START 변경처리한다.
+		// @param [IN] nMaxCout 추출 가능한 최대 갯수
+		// @param [OUT] 추출된 job 정보를 저장하기 위한 List
+		// @return false 추출 가능한 항목이 없을 경우.
+		//         true  그 외
+		bool GetDataToStart( const unsigned int nMaxCount, std::list<CCacheData>& listData );
+
+
+	private:
+		
+		// job 정보을 담당하는 map ( key-value 구조 )
+		// - key = content_length:uri 형식으로 구성하여 중복 제거 처리
+		std::map<std::string, CCacheData> m_mapJob;
+		
+		// map 객체에 대한 접근제어를 담당할 mutex lock
+		pthread_mutex_t m_mutexMap;
+
+
+	private:
+
+		// 전달받은 정보를 바탕으로 map 에 사용할 Key 값을 생성한다.
+		// key 값은 동일 Contnt 중복 방지를 위해
+		// content_length:filename_hash(경로정보를 제외한 Only hash name) 형식으로 구성한다.
+		// @param data [IN] content length 및 filename hash 정보가 저장된 CCacheRequestData 객체 참조
+		// @param strKey [OUT] 생성된 key 값.
+		bool GetKey( CCacheRequestData & data, std::string& strKey );
+						
+};
+
+#endif // __CACHE_JOB_LIST_H__

rcts/rc_rmcd/src/CacheOrder.cpp

@@ -0,0 +1,421 @@
+#include "CacheOrder.h"
+
+#include <errno.h>
+#include <string.h>
+
+#include "Database.h"
+#include "Logger.h"
+
+
+// 처리 loop 간의 sleep time 정의
+#define DEFAULT_SLEEP_TIME  3
+// RCDB 접속 실패 또는 Query 실패 등의 상황 발생시 
+#define MAX_SLEEP_TIME     30
+
+// Query 문장 저장을 위한 Buffer 크기
+#define DEFAULT_QUERY_BUFFER_SIZE 2048
+
+
+// 생성자
+// param [IN] pQueueCacheRequest Cache 요청 정보 저장 Queue 에 대한 포인터
+// param [IN] pListCacheJob Cache 생성 관련 Job List 객체에 대한 포인터
+// param [IN] pProperFhs Proper FHS 정보를 저장하는 객체에 대한 포인터
+CCacheOrder::CCacheOrder( CDataQueue<CCacheRequestData>* pQueueCacheRequest, CCacheJobList* pCacheJob, CProperFhs * pProperFhs )
+	: m_pQueueCacheRequest( pQueueCacheRequest )
+	, m_pCacheJob( pCacheJob )
+	, m_pProperFhs( pProperFhs )	
+{
+	m_threadHandle = 0;
+
+	m_uSleep = DEFAULT_SLEEP_TIME;
+
+	// NEW 2014-07-07 신규 멤버 변수 초기화 코드 추가.
+	// Init() 에서 RCDB 접속 실패가 발생 가능하므로.. 구형 RCDB 형상을 사용토록 설정.
+	m_bServiceTableSeparate = false;
+	
+}
+
+// 소멸자
+CCacheOrder::~CCacheOrder()
+{
+	// Thread 동작 정지 처리
+	// - 만약 Thread 가 이미 종료된 경우 m_threadHandle 이 다른 Thread Handle 일 수 있으므로 
+	//   업무 Flow 수정시 주의할 것
+	if( m_threadHandle != 0 )
+		pthread_cancel( m_threadHandle );    
+}
+
+// 객체 초기화 수행
+bool CCacheOrder::Init()
+{
+	// 생성자로 전달받은 각 객체에 대한 포인터는 유효하다가 판단하고....
+	// 각 멤버변수에 대한 검사는 수행하지 않는다.
+
+	// RCDB 접속 정보 Load.
+	m_rcdbInfo.Load();
+
+	// RCDB 접속 처리를 위한 객체 생성
+	DataBase rcdb;
+
+	// RCDB 접속 시도 및 접속 실패시
+	if( rcdb.PgOpenDB( m_rcdbInfo.m_strRcdbIp, m_rcdbInfo.m_nRcdbPort
+		, m_rcdbInfo.m_strRcdbName, m_rcdbInfo.m_strRcdbAcct
+		, m_rcdbInfo.m_strRcdbAcctPw ) == NULL )
+	{
+		LOG( LERR, "RCDB connection failed." );
+		return false;
+	}
+	else
+	{
+		// 접속 성공한 경우...
+		LOG( LINF, "RCDB connection test ok..." );
+
+		// NEW 2014-06-23 huibong
+		// 서비스 table 분리된 신규 형상인지.. 구형 형상인지 체크하여
+		// m_bServiceTableSeparate 변수 설정 처리.
+		// 해당 변수 초기화는 생성자에서 1차로 수행함.
+		char szQuery[1024];
+		snprintf( szQuery, 1023,
+			"SELECT * FROM pg_tables WHERE schemaname = 'public' AND tablename = 't_dav_resource' " );
+
+		rcdb.PgDoExec( szQuery );
+		if( rcdb.PgResult( DataBase::NOT_CLEAR ) < 0 )
+		{
+			// Query 수행 결과 오류 발생시...
+			// - pg_tables 가 존재하지 않을 경우 오류 발생 가능...
+			// - 이는 RCDB 가 아직 적절하게 구성되지 않았다는 의미이므로... Init()함수를 오류로 처리한다.
+			LOG( LERR, "RCDB t_dav_resource exist check failed.[%s][%s]", rcdb.GetErrorMessage().c_str(), szQuery );
+
+			rcdb.PgClear();
+			rcdb.PgCloseDB();
+
+			return false;
+		}
+		else
+		{
+			// Query 수행이 정상인 경우.
+			int  nResult = rcdb.GetNoTuples();
+			if( nResult > 0 )
+			{
+				// t_dav_resource 테이블이 존재하는 경우...
+				m_bServiceTableSeparate = false;
+				_LOG( LINF, "CCacheOrder: t_dav_resource table exist.[Old RCDB Type]" );
+			}
+			else
+			{
+				// t_dav_resource 테이블이 존재하지 않는 서비스별 테이블 분리 형상인 경우.
+				m_bServiceTableSeparate = true;
+				_LOG( LINF, "CCacheOrder: t_dav_resource table not exist.[New RCDB Type]" );
+			}
+		}
+
+		// RCDB 조회 결과 set 를 clear 처리 후 RCDB 접속 해제.
+		rcdb.PgClear();
+		rcdb.PgCloseDB();
+
+		return true;
+	}	
+}
+
+// thread를 생성하여 업무 flow 를 시작.
+bool CCacheOrder::Start()
+{
+	int nRet = ::pthread_create( &m_threadHandle, 0, CCacheOrder::threadFunc, this );
+	if( nRet != 0 )
+	{
+		// Thread 생성 실패시
+		int errorNum = errno;
+		LOG( LERR, "Thread create failed.[%d][%s]", errorNum, strerror( errorNum ) );
+
+		return false;
+	}
+	
+	return true;
+}
+
+// 스레드 함수
+void* CCacheOrder::threadFunc( void* arg )
+{
+	CCacheOrder* pObject = reinterpret_cast<CCacheOrder *>( arg );
+	pthread_detach( pthread_self() );
+
+	while( 1 )
+	{
+		pthread_testcancel();
+		pObject->Execute();
+		pthread_testcancel();
+
+		// 1회 수행 후 지정된 시간 만큼 대기
+		sleep( pObject->m_uSleep );
+	}
+
+	// NEW 2014-07-07 huibong
+	// Thread 종료시 m_threadHandle 값을 초기화 처리.
+	// - 소멸자에서 잘못된 Thread 를 종료할 수 있기 때문.
+	pObject->m_threadHandle = 0;
+		
+	return NULL;
+}
+
+// 스레드 내에서 각 loop 단위 처리 호출 함수.
+void CCacheOrder::Execute()
+{
+	// Request Cache Queue 상에 처리할 Data 가 존재하는 경우.
+	if( m_pQueueCacheRequest->GetSize() > 0 )
+	{
+		bool bResult = PushRequestToJob();
+		
+		// 처리 결과에 따라 loop sleep time 조정
+		if( bResult == true )
+			m_uSleep = DEFAULT_SLEEP_TIME;
+		else
+		{
+			// RCDB 연결 실패, Queury 수행 실패 등의 오류 발생시
+			m_uSleep = MAX_SLEEP_TIME;
+		}
+	}
+	else
+	{
+		// 처리할 Data 가 존재하지 않는 경우.
+		m_uSleep = DEFAULT_SLEEP_TIME;
+	}	
+}
+
+// Cache Requet Queue 에 저장된 요청을 검사하여....
+// cache 생성 Job 에 추가하는 기능을 수행
+bool CCacheOrder::PushRequestToJob()
+{
+	// RCDB 연결 관련 객체.
+	// - RCDB 연결은 Job 에 등록가능한 Data 가 존재할 경우에만 수행되도록 한다.
+	DataBase rcdb;
+	bool bDbConnected = false;  // RCDB 연결 상태 정보 저장 변수
+
+	// Queue 에서 Data 를 Pop 한 후
+	// 해당 정보가 CacheJobList 에 이미 등록된 정보인지 확인
+	// 미등록 정보인 경우 RCDB 조회를 수행하여 
+	// - Cache 를 수행할 FHS 정보를 선택한 후
+	// - 해당 Content 정보를 Cache Job 에 등록 처리한다.
+	
+	// queue 에서 꺼낸 정보를 저장하기 위한 변수
+	CCacheRequestData requestData;
+
+	// Query 문장 저장을 위한 버퍼 생성
+	char szQuery[DEFAULT_QUERY_BUFFER_SIZE];
+
+	// Query 수행 결과값 저장을 위한 변수..	
+	int nResult = 0;
+
+	while( m_pQueueCacheRequest->GetSize() > 0 )
+	{
+		// queue 에 저장된 첫번째 data 복사 (queue 에서 삭제된 상태 아님)		
+		requestData = m_pQueueCacheRequest->Front();
+
+		// 해당 정보를 Job List 에 저장 가능한지 확인
+		if( m_pCacheJob->IsExist( requestData ) == true )
+		{
+			// 이미 동일 정보가 Job List 에 존재하는 경우...
+			// queue 에서 pop 해서 버림.
+			_LOG( LINF, "Cache request already exist.[%s]", requestData.m_strFileNameHash.c_str() );
+
+			m_pQueueCacheRequest->Pop();
+			continue;
+		}
+
+		// RCDB 에서 해당 content 에 대한 정보 조회
+		
+		// DB 연결이 되지 않은 상태인 경우.
+		// - Queue 항목 중 Job 에 등록해야 하는 항목이 존재할 경우에만 RCDB 연결 목적
+		if( bDbConnected == false )
+		{
+			// RCDB 접속 시도
+			if( rcdb.PgOpenDB( m_rcdbInfo.m_strRcdbIp, m_rcdbInfo.m_nRcdbPort
+				, m_rcdbInfo.m_strRcdbName, m_rcdbInfo.m_strRcdbAcct
+				, m_rcdbInfo.m_strRcdbAcctPw ) == NULL )
+			{
+				// RCDB 접속이 안될때...
+				// - 현재 Queue 에 저장된 Cache Request 요청을 모두 버리고 
+				// - false 반환하여 특정시간 동안 sleep 되도록 처리.
+				LOG( LERR, "RCDB connection failed. Cache request all trhow [%u]"
+					, m_pQueueCacheRequest->GetSize() );
+
+				// Queue 요청 모두 삭제 처리
+				m_pQueueCacheRequest->Init();
+
+				return false;
+			}
+			else
+			{
+				bDbConnected = true;
+			}
+		}
+		
+		// Query 조립
+		// - 전달받은 filename_hash , content_length, FHS 정보를 이용하여 
+		// - 해당 물리 파일과 연결된 uri 추출 ( uri 를 직접 수신할 경우..대소문자 무시 기능 때문에 조회 불가)
+		// - 추출된 uri 와 연결된 장비 정보를 조회한다.
+		// - ORDER BY 조건에 의해 is_cache 값이 N-R-Y 순으로 나타남.
+		// - COPY 등으로 인해 Query 결과에는 중복된 host_name 이 존재 가능함.				
+		
+		// t_dav_resource 테이블 사용 RCDB 인 경우
+		if( m_bServiceTableSeparate == false )
+		{
+			sprintf( szQuery,
+				"SELECT host_name, filename_hash, is_cache "
+				"FROM t_dav_resource "
+				"WHERE uri IN "
+				"      ( SELECT uri FROM t_dav_resource "
+				"        WHERE filename_hash = '%s' "
+				"          AND host_name = '%s' "
+				"          AND get_content_length = %llu "
+				"          AND deleted_yn = 'N' "
+				"      ) "
+				" AND get_content_length = %llu "
+				" AND deleted_yn = 'N' "
+				"ORDER BY is_cache ASC; "
+				, requestData.m_strFileNameHash.c_str()
+				, requestData.m_strRequestHost.c_str()
+				, requestData.m_uContentLength
+				, requestData.m_uContentLength
+				);
+		}
+		else
+		{
+			// 신형 RCDB 형상인 경우.
+			sprintf( szQuery,
+				"SELECT host_name, filename_hash, is_cache "
+				"FROM t_meta_%s "
+				"WHERE uri IN "
+				"      ( SELECT uri FROM t_meta_%s "
+				"        WHERE filename_hash = '%s' "
+				"          AND host_name = '%s' "
+				"          AND get_content_length = %llu "
+				"          AND deleted_yn = 'N' "
+				"      ) "
+				" AND get_content_length = %llu "
+				" AND deleted_yn = 'N' "
+				"ORDER BY is_cache ASC; "
+				, requestData.m_strServiceSeq.c_str()
+				, requestData.m_strServiceSeq.c_str()
+				, requestData.m_strFileNameHash.c_str()
+				, requestData.m_strRequestHost.c_str()
+				, requestData.m_uContentLength
+				, requestData.m_uContentLength
+				);
+		}
+
+		
+		// Query 실행 및 결과 확인
+		rcdb.PgDoExec( szQuery );
+		nResult = rcdb.PgResult( DataBase::NOT_CLEAR );
+		if( nResult < 0 )
+		{
+			// RCDB t_dav_resource 테이블 조회 실패시
+			// - RCDB 연결 실패 또는 Query 실패로 인한 문제 발생 가능.
+			// - 따라서 RCDB 연결 해제 처리, Queue Pop 처리한 후
+			// - 루프를 계속 수행처리
+			LOG( LERR, "RCDB t_dav_resource cache select failed.[%s][%s]"
+				, rcdb.GetErrorMessage().c_str(), szQuery );
+			
+			rcdb.PgClear();
+			rcdb.PgCloseDB();
+			bDbConnected = false;
+
+			m_pQueueCacheRequest->Pop();
+			continue;
+		}
+
+		// 결과 Row 수 확인.
+		nResult = rcdb.GetNoTuples();
+		if( nResult <= 0 )
+		{
+			// 해당 Content 가 존재하지 않거나... 오류 발생시.
+			// - 그냥 버린다.
+			// - 이로 인해 FHS 에 meta 기준으로 삭제 불가능한 파일이 남게 된다.			
+			_LOG( LINF, "cache request content not found in RCDB.[%d] [%s][%s][%llu]"
+				, nResult
+				, requestData.m_strRequestHost.c_str() 
+				, requestData.m_strFileNameHash.c_str() 
+				, requestData.m_uContentLength );
+		
+		}
+		else
+		{
+			// 결과 Row 수가 존재하는 경우...
+			CCacheData cacheData;
+			cacheData.m_requestData = requestData;
+
+			// 결과 정보 중.. Request 요청을 보낸 장비가 아닌 FHS 을 Cache 생성 원본으로 선택
+			// - order by 조건에 의해 is_cache 가 N-R-Y 순으로 장비 정보가 나타나므로...
+			// - 원본, 복제본, cache 본 순으로 사용될 순서가 정해짐.
+			for( int i = 0; i < nResult; ++i )
+			{
+				// host name 이 같지 않은 경우.
+				if( strcasecmp( rcdb.GetValue( i, 0 ), requestData.m_strRequestHost.c_str() ) != 0 )
+				{
+					cacheData.m_strSourceHost         = rcdb.GetValue( i, 0 );
+					cacheData.m_strSourceFilenameHash = rcdb.GetValue( i, 1 );
+
+					// source 로 사용할 첫번째 장비를 찾은 경우...
+					// - 더 이상 루프는 의미가 없으므로..
+					break;
+				}
+			}
+
+			// 만약 원본 1개만 존재하는 경우...
+			// - 그냥 요청 정보를 그대로 사용.
+			if( cacheData.m_strSourceHost.empty() == true )
+			{
+				cacheData.m_strSourceHost         = requestData.m_strRequestHost;
+				cacheData.m_strSourceFilenameHash = requestData.m_strFileNameHash;
+			}
+			
+			// ignore FHS list 구성
+			// - 빠른 처리를 위해 조회 결과 처리시 중복 host_name 정보를 제거한다.
+			std::list<std::string> ignoreFhsList;
+			std::string strTemp;
+			for( int j = 0; j < nResult; ++j )
+			{
+				strTemp = rcdb.GetValue( j, 0 );
+				ignoreFhsList.push_back( strTemp );
+			}
+
+			// 중복 제거 ( sort() 후 unique() 함수 호출해야 중복 제거 가능 )
+			ignoreFhsList.sort();
+			ignoreFhsList.unique();
+
+			// Target FHS 선정 처리
+			std::vector<std::string> vecProperFhs;
+			if( m_pProperFhs->GetProperFhs( 1, vecProperFhs, ignoreFhsList ) == false )
+			{
+				// Proper FHS 선택 실패시...
+				// 해당 요청을 그냥 버린다... 
+				_LOG( LWAR, "cache request not found proper fhs. throw.[%s][%s][%llu]"
+					, requestData.m_strRequestHost.c_str()
+					, requestData.m_strFileNameHash.c_str()
+					, requestData.m_uContentLength );
+			}
+			else
+			{
+				// Proper FHS 선택 성공시..
+				// - 해당 정보를 CacheData 에 입력한 후... 
+				// - Job 으로 등록 처리
+				cacheData.m_strTargetHost = vecProperFhs.front();
+				m_pCacheJob->Register( cacheData );
+			}
+		}
+		
+		// Queue Pop 처리 후
+		// 다음 Query 사용을 대비하여 결과 set clear 처리.
+		m_pQueueCacheRequest->Pop();
+		rcdb.PgClear();
+	}
+	
+	// RCDB 연결이 되어 있는 경우.. 종료 처리
+	if( bDbConnected == true )
+	{
+		rcdb.PgClear();
+		rcdb.PgCloseDB();
+	}
+	
+	return true;
+}

rcts/rc_rmcd/src/CacheOrder.h

@@ -0,0 +1,96 @@
+/***************************************************************************
+                Cache 요청을 확인하여 Job 에 등록 처리를 수행
+                -----------------------------------------
+    begin      : 2010/03/11
+    copyright  : (C) 2010 Solbox Inc.
+    author     : storage dev team
+    email      : storage.sd@solbox.com
+    version    : 3.3
+
+    CopyRight(C) 2010 Solbox Inc. All Rights reserved.
+    Redistribution and use in source and binary forms, with or with out
+    modification, are not permitted in outside of Solbox Inc.
+***************************************************************************/
+
+#ifndef __CACHE_ORDER_H__
+#define __CACHE_ORDER_H__
+
+#include <pthread.h>
+
+#include "DataQueue.hpp"
+#include "CacheRequestData.h"
+#include "CacheJobList.h"
+#include "ProperFhs.h"
+#include "RcdbInfo.h"
+
+
+// CCacheOrder
+// FHS로부터 수신되어 Queue 에 저장된 Hot Content Cache 요청에 대해
+// 중복 요청 여부 확인 및 RCDB 에서 해당 Content 를 저장한 FHS 를 확인한 후
+// 실제 Cache 생성 작업이 진행되도록 Job List 에 저장하는 역활을 수행.
+// 내부적으로 Thread를 사용
+class CCacheOrder
+{
+	public:
+		
+		// 생성자
+		// param [IN] pQueueCacheRequest Cache 요청 정보 저장 Queue 에 대한 포인터
+		// param [IN] pCacheJob Cache 관련 Job List 객체에 대한 포인터
+		// param [IN] pProperFhs Proper FHS 정보를 저장하는 객체에 대한 포인터
+		CCacheOrder( CDataQueue<CCacheRequestData>* pQueueCacheRequest, CCacheJobList* pCacheJob, CProperFhs * pProperFhs );
+		
+		// 소멸자
+		~CCacheOrder();
+
+		// 객체 초기화 수행
+		bool Init();
+
+		// thread를 생성하여 업무 flow 를 시작.
+		bool Start();
+				
+	
+	private:
+
+		// Cache 요청 정보 저장 Queue 에 대한 포인터
+		// - 생성자를 통해 전달받음
+		CDataQueue<CCacheRequestData>* m_pQueueCacheRequest;
+
+		// Cache 관련 Job List 객체에 대한 포인터
+		// - 생성자를 통해 전달받음
+		CCacheJobList* m_pCacheJob;
+
+		// Proper FHS 정보를 저장하는 객체에 대한 포인터
+		// - 생성자를 통해 전달받음
+		CProperFhs* m_pProperFhs;
+	
+
+		// 내부 Thread 에 대한 ID
+		pthread_t m_threadHandle;
+
+		// RCDB 접속 정보를 저장할 변수.
+		CRcdbInfo m_rcdbInfo;
+		
+		// New 2014-07-07 huibong
+		// RCDB 형상변경에 따라 서비스별 Table 분리 여부 판단 flag
+		// TODO: 향후 신규 RCDB 형상 적용 완료 후 본 항목 제거 필요.
+		// - false : 기존 t_dav_resource 테이블 사용.
+		// - ture  : 신규 RCDB 형상 (서비스별 meta table 분리) 사용.
+		bool m_bServiceTableSeparate;
+
+		// Thread Loop 마다 Sleep Time 정보를 저장하기 위한 변수
+		unsigned int m_uSleep;
+		
+	private:
+
+		// 스레드 함수
+		static void* threadFunc( void* arg );
+
+		// 스레드 내에서 각 loop 단위 처리 호출 함수.
+		void Execute();
+		
+		// Cache Requet Queue 에 저장된 요청을 검사하여....
+		// cache 생성 Job 에 추가하는 기능을 수행.		
+		bool PushRequestToJob();
+
+};
+#endif // __CACHE_ORDER_H__ 

rcts/rc_rmcd/src/CacheRequestData.cpp

@@ -0,0 +1,98 @@
+#include "CacheRequestData.h"
+
+#include <stdlib.h>
+
+#include "Logger.h"
+
+
+CCacheRequestData::CCacheRequestData()
+{
+	m_uContentLength = 0;
+	m_uConcurrentFd  = 0;
+}
+
+// Set 함수
+void CCacheRequestData::Set( struct stCacheRequestBody * pRequestBody )
+{
+	m_strRcid         = pRequestBody->szRCID;
+	m_strFileNameHash = pRequestBody->szFileNameHash;
+	m_strRequestHost  = pRequestBody->szHostname;
+	m_strServiceSeq   = pRequestBody->szServiceID;
+
+	m_uContentLength = atoll( pRequestBody->szContentLength );
+	m_uConcurrentFd  = atoi( pRequestBody->szFDCount );
+
+	Trim( m_strRcid );
+	Trim( m_strFileNameHash );
+	Trim( m_strServiceSeq );
+}
+
+// 본 객체의 재사용을 위한 멤버 변수 초기화 함수
+void CCacheRequestData::Init()
+{
+	m_strRcid.clear();
+	m_strFileNameHash.clear();
+	m_strRequestHost.clear();
+	m_strServiceSeq.clear();
+	m_uContentLength = 0;
+	m_uConcurrentFd = 0;
+}
+
+// Key 값 생성 지원을 위해 수신된 filename_hash 정보 중
+// 경로 정보를 제외한 hash name 만을 반환 처리한다.
+// @param [OUT] value 추출된 hash name 정보 ( 경로정보 제외 )
+// @return false hash name 정보가 유효화지 않은 경우.
+//         true  정상.
+bool CCacheRequestData::GetOnlyHashFileName( std::string & value )
+{
+	if( m_strFileNameHash.empty() == true )
+		return false;
+
+	std::string::size_type pos = m_strFileNameHash.rfind( '/' );
+	if( pos == std::string::npos )
+	{
+		// 잘못된 filename_hash 정보임.
+		return false;
+	}
+
+	// 경로 부분을 제외한 hash filename 부분만 추출.
+	value = m_strFileNameHash.substr( pos + 1 );
+	if( value.empty() == true )
+		return false;
+	
+	return true;
+}
+
+
+void CCacheRequestData::Print()
+{
+	_LOG( LDBG, "---- cache request data ----" );
+
+	_LOG( LDBG, "rc id          [%s]", m_strRcid.c_str() );
+	_LOG( LDBG, "filename_hash  [%s]", m_strFileNameHash.c_str() );
+	_LOG( LDBG, "host name      [%s]", m_strRequestHost.c_str() );
+	_LOG( LDBG, "service id     [%s]", m_strServiceSeq.c_str() );
+	_LOG( LDBG, "content length [%llu]", m_uContentLength );
+	_LOG( LDBG, "fd count       [%u]", m_uConcurrentFd );
+	
+	_LOG( LDBG, "-----------------------------" );
+
+	return;
+}
+
+// std 상에 trim 함수가 없어서 직접 구현 아니면 boost/algorithm/string.hpp 상의 boost::trim 함수 사용
+void CCacheRequestData::Trim( std::string & str )
+{
+	if( str.length() == 0 )
+		return;
+
+	// 문자열 뒤의 공백, TAB, CR 등의 문자 제거처리.
+	std::string::size_type pos = str.find_last_not_of( " \a\b\f\n\r\t\v" );
+	if( pos != std::string::npos )
+		str.erase( pos + 1 );
+
+	// 문자열 앞의 공백, TAB, CR 등의 문자 제거처리.
+	pos = str.find_first_not_of( " \a\b\f\n\r\t\v" );
+	if( pos != std::string::npos )
+		str.erase( 0, pos );
+}

rcts/rc_rmcd/src/CacheRequestData.h

@@ -0,0 +1,92 @@
+/***************************************************************************
+                Cache 생성 요청 Data 정보 저장 Class
+                -----------------------------------------
+    begin      : 2014/07/08
+    copyright  : (C) 2005 Solbox Inc.
+    author     : Storage Dev Team
+    email      : storage.sd@solbox.com
+    version    : 3.3
+
+    CopyRight(C) 2005 Solbox Inc. All Rights reserved.
+    Redistribution and use in source and binary forms, with or with out
+    modification, are not permitted in outside of Solbox Inc.
+***************************************************************************/
+
+#ifndef __CACHE_REQUEST_DATA_H__ 
+#define __CACHE_REQUEST_DATA_H__
+
+#include <string>
+
+// fimngd 로 부터 수신된 Hot Content 정보 수신 관련 packet body 구조체.
+// sizeof() : 1252 Byte (64Bit OS)
+struct stCacheRequestBody {
+
+	char  szRCID[32];            // RC ID 정보
+	char  szFileNameHash[1024];  // FHS 에 저장된 filename_hash 정보
+	char  szHostname[128];       // cache 발생 요청 장비의 Host Name
+	char  szServiceID[32];       // service sequence ( 구 tran_id )
+	char  szContentLength[32];   // content length ( 실제 물리 File size )
+	char  szFDCount[4];          // 해당 content 의 참조 count.
+};
+
+
+// CCacheRequestData
+// FHS 로 부터 수신된 Hot Content 정보 와 
+// Cache 생성을 위한 관련 정보를 저장하기 위한 data class.
+class CCacheRequestData
+{
+    public:
+
+		// 생성자
+		CCacheRequestData();
+
+		// 소멸자
+		~CCacheRequestData(){};
+
+		// Set 함수
+		void Set( struct stCacheRequestBody * pRequestBody );
+
+		// 본 객체의 재사용을 위한 멤버 변수 초기화 함수
+		void Init( void );
+
+		// Key 값 생성 지원을 위해 수신된 filename_hash 정보 중
+		// 경로 정보를 제외한 hash name 만을 반환 처리한다.
+		// @param [OUT] value 추출된 hash name 정보 ( 경로정보 제외 )
+		// @return false hash name 정보가 유효화지 않은 경우.
+		//         true  정상.
+		bool GetOnlyHashFileName( std::string & value );
+
+		// Debug 목적 함수.
+		void Print( void );
+
+
+	public:
+
+		// RC ID 정보 ( FHS 수신 정보 )
+		std::string m_strRcid;
+
+		// filename_hash 정보( FHS 수신 정보 )
+		std::string m_strFileNameHash;
+
+		// Cache 생성을 요청한 Host 정보 ( FHS 수신 정보 )
+		std::string m_strRequestHost;
+
+		// Service sequece (구 tran_id) 정보 ( FHS 수신 정보 )
+		std::string m_strServiceSeq;
+
+		// Content length 정보 ( FHS 수신 정보 )
+		unsigned long long m_uContentLength;
+
+		// 동접 fd 갯수 ( FHS 수신 정보 )
+		unsigned int m_uConcurrentFd;
+
+
+
+	private:
+
+		// URI 항목 Trim 처리를 위한 함수
+		void Trim( std::string & str );
+						
+};
+
+#endif // __CACHE_REQUEST_DATA_H__

rcts/rc_rmcd/src/CacheThread.cpp

@@ -0,0 +1,320 @@
+#include "CacheThread.h"
+
+#include <errno.h>
+#include <time.h>
+#include <string.h>
+
+#include "Logger.h"
+#include "FtsdSocketControl.h"
+#include "ServiceConfig.h"
+
+
+// ftsd 로 부터 처리 결과 수신을 위한 Total 대기 시간 정의 ( sec )
+#define FHS_RESPONSE_TOTAL_TIMEOUT  3600   // ( sec, 1 hour )
+
+// ftsd 로 부터 응답 수신 확인을 위한 socket read timeout (sec)
+#define FHS_RESPONSE_CHECK_TIMEOUT  3      // 3 sec
+
+
+CCacheThread::CCacheThread( CProcessStatus* pProcessStatus
+	, CCacheJobList* pJobList
+	, CDataQueue<CCacheData>* pQueueCacheComplete
+	, CCacheData& dataCache )
+	: m_pProcessStatus( pProcessStatus )
+	, m_pCacheJob( pJobList )
+	, m_pQueueCacheComplete( pQueueCacheComplete )
+	, m_dataCache( dataCache )
+{
+	// 멤버 변수 초기화
+	m_threadHandle = 0;
+}
+
+
+CCacheThread::~CCacheThread()
+{
+	// Thread 동작 정지 처리
+	// - 만약 Thread 가 이미 종료된 경우 m_threadHandle 이 다른 Thread Handle 일 수 있으므로 
+	//   업무 Flow 수정시 주의할 것
+	if( m_threadHandle != 0 )
+		pthread_cancel( m_threadHandle );    
+}
+
+// thread를 생성하여 Cache 생성 작업을 수행.
+bool CCacheThread::Start()
+{
+	int nRet = ::pthread_create( &m_threadHandle, NULL, CCacheThread::threadFunc, this );
+	if( nRet != 0 )
+	{
+		// Thread 생성 실패시
+		int errorNum = errno;
+		LOG( LERR, "Thread create failed.[%d][%s]", errorNum, strerror( errorNum ) );
+
+		return false;
+	}
+
+	return true;
+}
+
+// 스레드 함수
+void* CCacheThread::threadFunc( void* arg )
+{
+	CCacheThread* pObject = reinterpret_cast<CCacheThread *>( arg );
+	pthread_detach( pthread_self() );
+
+	pthread_testcancel();
+	// Thread 동작시 Thread Count 1 증가 처리
+	pObject->m_pProcessStatus->AddReplicationCount();
+
+	// 실제 작업 수행.
+	pObject->Execute();
+
+	// Thread 동작 완료시 Thread Count 1 감소 처리
+	pObject->m_pProcessStatus->SubtractReplicationCount();
+	pthread_testcancel();
+
+
+	// NEW 2014-06-25 huibong
+	// Thread 종료시 m_threadHandle 값을 초기화 처리.
+	// - 소멸자에서 잘못된 Thread 를 종료할 수 있기 때문.
+	pObject->m_threadHandle = 0;
+
+	// 객체 자동 delete 처리.
+	delete pObject;
+	return NULL;
+}
+
+// 실제 Cache 생성 작업을 수행
+void CCacheThread::Execute()
+{
+	// 1. FHS 의 ftsd 와 통신 처리를 담당할 socket control 객체 생성.
+	CFtsdSocketControl fhs;
+
+	// 2. Source Content를 가진 FHS ftsd 에 접속 수행.
+	bool bResult = fhs.ConnectTarget( m_dataCache.m_strSourceHost, CServiceConfig::GetInstance()->GetFhsTransferDaemonPort() );
+	if( bResult == false )
+	{
+		// 원본 FHS 와 접속 실패시
+		// - 그냥 실패로 처리 ( Job 에서 본 항목 제거 처리 후 Thread 종료 )	
+		_LOG( LERR, "CCacheThread: source fhs[%s] connect fail."
+			, m_dataCache.m_strSourceHost.c_str() );
+
+		m_pCacheJob->UnRegister( m_dataCache );		
+		return;
+	}
+
+	// 3. 연결된 Source FHS 로 Cache 생성 요청을 전달
+	std::vector<std::string> vecTargetFHS;
+	vecTargetFHS.push_back( m_dataCache.m_strTargetHost );
+
+	bResult = fhs.SendFileCacheRequest( m_dataCache.m_strSourceFilenameHash
+	                                  , m_dataCache.m_requestData.m_uContentLength
+		                              , CServiceConfig::GetInstance()->GetHashCheckLevel()
+		                              , true
+		                              , vecTargetFHS );
+
+	if( bResult == false )
+	{
+		// Cache 생성 요청 전달 실패시
+		// - 그냥 실패로 처리 ( Job 에서 본 항목 제거 처리 후 Thread 종료 )	
+		_LOG( LERR, "CCacheThread: cache request send fail. [%s][%s]"
+			, m_dataCache.m_strSourceHost.c_str()
+			, m_dataCache.m_strSourceFilenameHash.c_str() );
+		
+		m_pCacheJob->UnRegister( m_dataCache );
+		return;
+	}
+
+	// 4. FHS 로 부터 처리 결과를 수신할때 까지 대기
+	//    - 이상 상황 발생시 무한 대기 가능성이 존재하므로.. 
+	//      미리 정의된 FHS_RESPONSE_TOTAL_TIMEOUT 까지만 대기하도록 한다.
+
+	// response timeout 처리를 위한 변수
+	time_t timeStart;
+	time_t timeNow;
+
+	// 응답 결과를 저장하기 위한 변수
+	int nResult;
+	bool bSuccess = false;
+	std::string szErrorMessage;
+
+	// 대기 시작 전 현재시간을 구한다.
+	timeStart = time( &timeStart );
+
+	// FHS 로 부터 응답 수신 대기
+	while( 1 )
+	{
+		// FHS 로 부터 응답 수신 처리
+		// -1 : 연결 종료
+		//  0 : Timeout 발생
+		//  1 : 응답 수신
+		//  2 : 복제 관련 응답이 아닌 다른 응답인 경우.. (발생하지 않지만.. 혹시나)
+		nResult = fhs.GetFileCacheResult( FHS_RESPONSE_CHECK_TIMEOUT
+			                            , bSuccess
+										, szErrorMessage
+										, m_mapSuccessFhs
+										, m_mapFailFhs );
+
+		if( nResult == 0 )
+		{
+			// 지정된 시간동안 응답 결과를 수신하지 못한 경우
+			// - FHS 와 연결이 정상인지 Alive 체크 호출
+			// - 만약 연결이 끝어진 경우.. 다음 loop 에서 -1 연결 종료가 리턴됨.
+			if( fhs.SendAliveCheck() == false )
+			{
+				_LOG( LERR, "CCacheThread: alive check fail.[%s][%s]"
+					, m_dataCache.m_strSourceHost.c_str()
+					, m_dataCache.m_strSourceFilenameHash.c_str() );
+			}
+
+			// Timeout 이 발생했으므로 바로 재시도하지 않고 조금 대기 후 다시 시도.
+			sleep( 1 );
+		}
+		else if( nResult == 1 )
+		{
+			// FHS 로 부터 응답을 수신한 경우.
+			// - Content 이상으로 인해 전송 자체를 하지 못했는지 여부 판단
+			if( bSuccess == true )
+			{
+				// 정상적으로 Cache 생성 처리된 경우..
+				_LOG( LDBG, "CCacheThread: result receive.[%s][%s]"
+					, m_dataCache.m_strSourceHost.c_str()
+					, m_dataCache.m_strSourceFilenameHash.c_str() );
+
+				DoSuccessProcess();
+			}
+			else
+			{
+				// Content 이상으로 인해 Cache 원본 Content 자체에 문제가 있는 경우.
+				// - 그냥 실패로 처리 ( Job 에서 본 항목 제거 처리 후 Thread 종료 )	 
+				_LOG( LERR, "CCacheThread: error result receive.[%s][%s][%s][%llu]"
+					, szErrorMessage.c_str()
+					, m_dataCache.m_strSourceHost.c_str()
+					, m_dataCache.m_strSourceFilenameHash.c_str()
+					, m_dataCache.m_requestData.m_uContentLength );
+				
+				m_pCacheJob->UnRegister( m_dataCache );
+			}
+
+			// 처리 결과를 수신했으므로 loop 종료.
+			break;
+		}
+		else if( nResult == -1 )
+		{
+			// FHS 와 연결이 끝어진 경우.
+			// - 그냥 실패로 처리 ( Job 에서 본 항목 제거 처리 후 Thread 종료 )	 
+			_LOG( LERR, "CCacheThread: fhs connection broken.[%s][%s]"
+				, m_dataCache.m_strSourceHost.c_str()
+				, m_dataCache.m_strSourceFilenameHash.c_str() );
+
+			m_pCacheJob->UnRegister( m_dataCache );
+			
+			break;
+		}
+		else if( nResult == 2 )
+		{
+			// Cache 관련 응답이 아닌 경우
+			// - 무시
+			;
+		}
+		else
+		{
+			// 기타 정의되지 않은 결과값 반환시
+			// - FHS 와 세션 이상이 발생할 수 있으므로 
+			// - 그냥 실패로 처리 ( Job 에서 본 항목 제거 처리 후 Thread 종료 )	 
+			_LOG( LERR, "CCacheThread: receive undefine result.[%d][%s][%s]"
+				, nResult
+				, m_dataCache.m_strSourceHost.c_str()
+				, m_dataCache.m_strSourceFilenameHash.c_str() );
+
+			m_pCacheJob->UnRegister( m_dataCache );
+
+			break;
+		}
+
+		// Total Reponse 대기 시간 확인
+		if( difftime( time( &timeNow ), timeStart ) > FHS_RESPONSE_TOTAL_TIMEOUT )
+		{
+			// Total Response Timeout 발생시
+			// - 그냥 실패로 처리 ( Job 에서 본 항목 제거 처리 후 Thread 종료 )	 			
+			_LOG( LERR, "CCacheThread: cache result receive timeout.[%s][%s]"
+				, m_dataCache.m_strSourceHost.c_str()
+				, m_dataCache.m_strSourceFilenameHash.c_str() );
+
+			m_pCacheJob->UnRegister( m_dataCache );
+			break;
+		}
+	} // while(1)	
+}
+
+
+void CCacheThread::DoSuccessProcess()
+{
+	// 멤버 변수에 저장된 정보를 처리하기 위한 iterator
+	std::map<std::string, std::string>::iterator itSuccessFhs;
+	
+	// m_mapSuccessFhs 에 저장된 성공 결과에 대한 처리
+	// - success fhs host, hash_name 의 정보 저장된 상태
+	// - Complete Queue 에 저장.
+	for( itSuccessFhs = m_mapSuccessFhs.begin(); itSuccessFhs != m_mapSuccessFhs.end(); ++itSuccessFhs )
+	{
+		m_dataCache.m_strTargetHost = itSuccessFhs->first;
+		m_dataCache.m_strTargetFilenameHash = itSuccessFhs->second;
+
+		// complete queue 에 저장 처리
+		// - complete queue 가 full 상태일 수 있어 push 실패 가능성 존재
+		// - 하지만... complete queue 에 저장 못할 경우...
+		//   FHS 에 생성된 Cache 는 처치 곤란한 쓰레기가 될 수 있으므로....	최대한 push 처리
+		// - 만약 최종 push 실패시.. Job 에서 해당 항목 삭제 후 throw 처리한다.
+		int nRetry = 0;
+		while( m_pQueueCacheComplete->Push( m_dataCache ) == false )
+		{
+			++nRetry;
+
+			if( nRetry > 3 )
+			{
+				_LOG( LWAR, "Cache complete queue push fail. throw [%s][%s]"
+					, m_dataCache.m_strTargetHost.c_str()
+					, m_dataCache.m_strTargetFilenameHash.c_str() );
+
+				// 최종 Job 항목에서 삭제 처리한다.
+				m_pCacheJob->UnRegister( m_dataCache );
+
+				break;
+			}
+			else
+			{
+				// push 실패시 잠시 대기 후 재시도
+				sleep( 1 );
+			}
+		}
+	}
+
+	// m_mapFailFhs 에 저장된 실패 결과에 대한 처리
+	// - 로깅만 수행한다.
+	if( m_mapFailFhs.empty() == false )
+	{
+		// 멤버 변수에 저장된 정보를 처리하기 위한 iterator
+		// - failed fhs host, error message
+		std::map<std::string, std::string>::iterator itFailFhs;
+
+		// 실패 내역에 대한 로깅		
+		for( itFailFhs = m_mapFailFhs.begin(); itFailFhs != m_mapFailFhs.end(); ++itFailFhs )
+		{
+			_LOG( LWAR, "CCacheThread: cache create fail [%s][%s]->[%s][%s]"
+				, m_dataCache.m_strSourceHost.c_str()
+				, m_dataCache.m_strSourceFilenameHash.c_str()
+				, itFailFhs->first.c_str()
+				, itFailFhs->second.c_str() );
+		}
+
+		// 최종 성공 항목은 존재하지 않고... 실패항목만 존재하는 경우..
+		// 실패로 판단하고.. Job 항목에서 제거 처리한다.
+		if( m_mapSuccessFhs.empty() == true )
+		{
+			// 최종 Job 항목에서 삭제 처리한다.
+			m_pCacheJob->UnRegister( m_dataCache );
+		}
+	}
+
+	return;
+}

rcts/rc_rmcd/src/CacheThread.h

@@ -0,0 +1,90 @@
+/***************************************************************************
+           Cache 생성 작업을 수행하는 Thread class
+                -----------------------------------------
+    begin      : 2010/03/13
+    copyright  : (C) 2010 Solbox Inc.
+    author     : storage dev team
+    email      : storage.sd@solbox.com
+    version    : 3.3
+
+    CopyRight(C) 2010 Solbox Inc. All Rights reserved.
+    Redistribution and use in source and binary forms, with or with out
+    modification, are not permitted in outside of Solbox Inc.
+***************************************************************************/
+
+#ifndef __CACHE_THREAD_H__
+#define __CACHE_THREAD_H__
+
+#include <pthread.h>
+#include <map>
+#include <string>
+
+#include "ProcessStatus.h"
+#include "CacheData.h"
+#include "CacheJobList.h"
+#include "DataQueue.hpp"
+
+
+// CCacheThread
+// 전달받은 Content 에 대해 각 FHS 와 통신을 통해 실제 Cache 생성을 수행
+// - Cache 정보 및 FHS 정보를 SocketControl 을 이용하여 ftsd 로 전송
+// - 처리 결과 수신 후 CompletQueue 결과 저장처리
+// 내부적으로 Thread를 사용
+class CCacheThread
+{
+    public:
+
+        // 생성자        
+		CCacheThread( CProcessStatus* pProcessStatus
+			        , CCacheJobList* pJobList
+			        , CDataQueue<CCacheData>* pQueueCacheComplete
+			        , CCacheData& dataCache );
+		
+		~CCacheThread();
+        
+		// thread를 생성하여 Cache 생성 작업을 수행.
+		bool Start();
+        
+    private:
+		
+		// 프로세스 상의 Queue, Thread 상태를 관리하는 CProcessStatus 객체에 대한 포인터
+		// - 생성자를 통해 전달받음        
+		CProcessStatus * m_pProcessStatus;
+        
+		// Cache 생성 관련 Job List 객체에 대한 포인터
+		// - 생성자를 통해 전달받음
+		CCacheJobList* m_pCacheJob;
+		
+		// Cache 생성 완료 저장 Queue 에 대한 포인터
+		// - 생성자를 통해 전달받음
+		CDataQueue<CCacheData>* m_pQueueCacheComplete;
+
+		// Cache 생성 대상 content 정보
+		// - 생성자를 통해 전달받음
+		CCacheData m_dataCache;
+        
+
+		// 내부 Thread 에 대한 ID
+		pthread_t m_threadHandle;
+		
+		// ftsd 로 부터 정상 처리된 결과 정보를 수신하기 위한 멤버 객체
+		// - success fhs host, hash_name
+		std::map<std::string, std::string> m_mapSuccessFhs;
+
+		// ftsd 로 부터 실패 처리된 결과 정보를 수신하기 위한 멤버 객체
+		// - failed fhs host, error message
+		std::map<std::string, std::string> m_mapFailFhs;
+        
+        
+	private:
+
+		// 스레드 함수
+		static void* threadFunc( void* arg );
+
+		// 실제 Cache 생성 작업을 수행
+		void Execute();
+		        
+       void DoSuccessProcess();
+ 
+};
+#endif //__CACHE_THREAD_H__

rcts/rc_rmcd/src/DataQueue.hpp

@@ -0,0 +1,170 @@
+/****************************************************************************
+                Data Object Queue Template class Class 
+                -----------------------------------------
+
+    begin      : 2014/06/13
+    copyright  : (C) 2005 Solbox Inc.
+    author     : 개발팀 스토리지 담당.
+    email      : storage.sd@solbox.com
+    version    : 3.4.0
+
+    CopyRight(C) 2005 Solbox Inc. All Rights reserved.
+    Redistribution and use in source and binary forms, with or with out
+    modification, are not permitted in outside of Solbox Inc.
+*****************************************************************************/
+
+/* 참고사항
+* 본 Template Class 는 기존 CQueue 클래스가 가지고 있는 문제점을 대체하기 위해 
+* 새로 개발된 class 임.
+* 자세한 사항은 이슈 #19042 참고
+*/
+
+#ifndef __DATA_QUEUE_HPP__
+#define __DATA_QUEUE_HPP__
+
+#include <queue>
+#include <pthread.h>
+
+#define QUEUE_DEFAULT_MAX_SIZE   0
+
+template <typename T>
+class CDataQueue
+{
+	private:
+
+		// data 객체를 저장할 queue.
+		std::queue<T> m_queue;
+
+		// queue 접근을 제어할 뮤텍스 lock.
+		pthread_mutex_t m_mutexQueue;
+
+		// queue 의 최대 크기 제한값 저장 변수.
+		unsigned int m_uMaxSize;
+		
+	public:
+
+		// 생성자
+		CDataQueue() {
+			m_uMaxSize = QUEUE_DEFAULT_MAX_SIZE;
+			pthread_mutex_init( &m_mutexQueue, NULL );
+		}
+
+		// 소멸자
+		~CDataQueue() {
+			pthread_mutex_destroy( &m_mutexQueue );
+		}
+		////////////////////////////////////
+
+		// queue 크기를 반환
+		unsigned int GetSize( void );
+
+		// queue Max 크기를 반환
+		unsigned int GetMaxSize( void );
+
+		// queue Max 크기를 설정
+		void SetMaxSize( unsigned int uMaxSize );
+
+		// 초기화
+		void Init( void );
+
+		// Data Object 저장
+		bool Push( T const& object );
+
+		// queue 에 저장된 첫번재 element 반환
+		// - queue 크기가 0 인 경우 호출시 std::out_of_range 오류가 발생해야 하지만...
+		//   예외 처리를 대부분 하지 않으므로... 빈 객체를 반환처리하도록 함.
+		//   따라서...꼭 GetSize() 함수를 호출하여 data 가 존재하는지 확인한 후 본 함수 호출할 것.
+		T Front( void );
+
+		// queue 에 저장된 첫번재 element 제거
+		void Pop( void );
+						
+};
+
+///////////////////////////////////////////////
+
+// queue 크기를 반환
+template <typename T>
+unsigned int CDataQueue<T>::GetSize( void )
+{
+	return m_queue.size();	
+}
+
+// queue Max 크기를 반환
+template <typename T>
+unsigned int CDataQueue<T>::GetMaxSize( void )
+{
+	return m_uMaxSize;
+}
+
+// queue Max 크기를 설정
+template <typename T>
+void CDataQueue<T>::SetMaxSize( unsigned int uMaxSize )
+{
+	m_uMaxSize = uMaxSize;
+}
+
+// 초기화
+template <typename T>
+void CDataQueue<T>::Init( void )
+{
+	// queue clear 처리를 수행.
+	// - queue 의 경우 clear 함수가 지원되지 않으므로 size 가 0 이 될때까지 pop 처리	
+	pthread_mutex_lock( &m_mutexQueue );
+
+	while( m_queue.empty() == false )
+		m_queue.pop();
+	
+	pthread_mutex_unlock( &m_mutexQueue );
+	return;
+}
+
+// Data Object 저장
+template <typename T>
+bool CDataQueue<T>::Push( T const& object )
+{
+	// 현재 queue size 가 설정된 최대 size 를 이상인 경우 실패 처리.
+	if( m_queue.size() >= m_uMaxSize )
+		return false;
+	else
+	{
+		pthread_mutex_lock( &m_mutexQueue );
+		m_queue.push( object );
+		pthread_mutex_unlock( &m_mutexQueue );
+		return true;
+	}
+}
+// queue 에 저장된 첫번재 element 반환
+template <typename T>
+T CDataQueue<T>::Front( void )
+{
+	// queue 특성상 pop, front 처리시 queue 가 비어있지 않음을 보장해야 한다.
+	// - 만약 queue 가 빈 경우.. std::out_of_range 예외를 발생시켜야 하지만...
+	//   호출 함수에서 이런 예외를 처리하지 않으므로... 
+	//   빈 깡통 객체를 전달한다.
+
+	T object;
+	if( m_queue.empty() == false )
+	{
+		pthread_mutex_lock( &m_mutexQueue );
+		object = m_queue.front();
+		pthread_mutex_unlock( &m_mutexQueue );
+	}
+	return object;
+}
+
+// queue 에 저장된 첫번재 element 제거
+template <typename T>
+void CDataQueue<T>::Pop( void )
+{
+	// queue 특성상 pop, front 처리시 queue 가 비어있지 않음을 보장해야 한다.
+	if( m_queue.empty() == false )
+	{
+		pthread_mutex_lock( &m_mutexQueue );
+		m_queue.pop();
+		pthread_mutex_unlock( &m_mutexQueue );
+	}
+	return;
+}
+
+#endif /* __DATA_QUEUE_HPP__ */

rcts/rc_rmcd/src/Database.cpp

@@ -0,0 +1,185 @@
+/***************************************************************************
+                Database Class
+                -----------------------------------------
+    begin      : 2010/03/09
+    copyright  : (C) 2010 SolutionBox Inc.
+	author     : Service 1 Team
+	email      : svc1@solbox.com
+    version    : 1.0
+
+    CopyRight(C) 2010 SolutionBox Inc. All Rights reserved.
+    Redistribution and use in source and binary forms, with or with out
+    modification, are not permitted in outside of SolutionBox Inc.
+***************************************************************************/
+
+#include <string.h>
+#include <stdlib.h>
+#include <sstream>
+#include "Database.h"
+#include "Logger.h"
+
+
+DataBase::~DataBase()
+{
+	if(m_PGconn != NULL) {
+		PgCloseDB();
+	}
+}
+
+PGconn *DataBase::PgOpenDB(string &strHost, int Port, string &strDBName, string &strAcct, string &strPasswd, int timeout)
+{
+	ostringstream conninfo;
+
+	// CHG 2014-10-29 huibong
+	// application_name add to logging RCDB
+
+	conninfo << "host=" << strHost << " port=" << Port << " dbname=" << strDBName <<
+		" user=" << strAcct << " password=" << strPasswd << " connect_timeout=" << timeout <<
+		" application_name=" << PROG_NAME;
+
+#ifdef _USE_LIBPQ_KEEPALIVE
+ 	// This option is supported by at least 9.1.2. and Currently supports Linux systems.
+	conninfo <<" keepalives=1";
+#endif  //  _USE_LIBPQ_KEEPALIVE
+
+	//m_PGconn = PQsetdbLogin(strHost.c_str(), szPort, NULL, NULL, strDBName.c_str(), strAcct.c_str(), strPasswd.c_str());
+	m_PGconn = PQconnectdb(conninfo.str().c_str());
+	if(PQstatus(m_PGconn) == CONNECTION_BAD) {
+		return NULL;
+	}
+	
+	return m_PGconn;
+}
+
+PGconn *DataBase::PgOpenDB(const char *pszDBName)
+{
+	m_PGconn = PQsetdb(NULL, NULL, NULL, NULL, pszDBName);
+	if(PQstatus(m_PGconn) == CONNECTION_BAD) {
+		return NULL;
+	}
+	return m_PGconn;
+}
+
+void DataBase::PgCloseDB()
+{
+	if(m_PGconn != NULL) 
+	{
+		PQfinish(m_PGconn);
+		m_PGconn = NULL;
+	}
+}
+
+int DataBase::PgResult(CFLAG flag)
+{
+	int fRet = 0;
+	int Result;
+
+	Result = PQresultStatus(m_pRes);
+	switch(Result) {
+		case  PGRES_EMPTY_QUERY :
+									fRet = -1;
+									break;
+		case  PGRES_BAD_RESPONSE :
+									fRet = -2;
+									break;
+		case  PGRES_NONFATAL_ERROR :
+									fRet = -3;
+									break;
+		case  PGRES_FATAL_ERROR :
+									fRet = -4;
+									break;
+	    case  PGRES_TUPLES_OK :
+									fRet = 1;
+									break;
+		case  PGRES_COMMAND_OK :
+									fRet = 2;
+									break;
+	}
+	if(fRet < 0) {
+		m_ErrorMessage = PQresultErrorMessage(m_pRes);
+	}
+	m_ResultCode = Result;
+	if(flag == CLEAR && m_pRes) {
+		PQclear(m_pRes);
+		m_pRes = NULL;
+	}
+	return fRet;
+}
+
+string &DataBase::GetErrorMessage()
+{
+	return m_ErrorMessage;
+}
+
+int DataBase::GetCmdTuples()
+{
+	//fprintf(stderr, "DataBase::GetCmdTuples PQcmdTuples %s\n", PQcmdTuples(m_pRes));
+	return (int)atoi(PQcmdTuples(m_pRes));
+}
+
+int DataBase::GetNoTuples()
+{
+	return PQntuples(m_pRes);
+}
+
+int DataBase::GetNoFields()
+{
+	return PQnfields(m_pRes);
+}
+
+PGresult *DataBase::GetRes()
+{
+	return m_pRes;
+}
+
+void DataBase::PgClear()
+{
+	if(m_pRes)
+	{
+		PQclear(m_pRes);
+		m_pRes = NULL;
+	}	
+}
+
+char *DataBase::GetValue(int tuple, int field)
+{
+	return PQgetvalue(m_pRes, tuple, field);
+}
+
+int DataBase::PgDoExec(char *pszQuery)
+{
+	return this->PgDoExec(pszQuery, NOT_CLEAR);
+}
+
+int DataBase::PgDoExec(string &strQuery)
+{
+	return this->PgDoExec((char *)strQuery.c_str(), NOT_CLEAR);
+}
+
+int DataBase::PgDoExec(char *pszQuery, CFLAG flag)
+{
+	if(m_PGconn == NULL) return -1;
+	if(PQstatus(m_PGconn) != CONNECTION_OK)  return -2;
+	m_pRes = PQexec(m_PGconn, pszQuery);
+	int r =	PgResult(flag);
+	return r;
+}
+
+int DataBase::PgDoExecParams(char *pszQuery, int nParamCnt, const char * const *paramValues ,CFLAG flag)
+{
+	if(m_PGconn == NULL) return -1;
+	if(PQstatus(m_PGconn) != CONNECTION_OK)  return -2;
+	m_pRes = PQexecParams(m_PGconn, pszQuery, nParamCnt, NULL, paramValues, NULL, NULL, 0);
+	int r =	PgResult(flag);
+	return r;
+
+}
+
+int DataBase::PgEscapeString(char *to, const char *from, size_t length)
+{
+	int retval = 0;
+
+	//PQescapeStringConn(m_PGconn, to, from, length, &retval);
+	PQescapeString(to, from, length);
+	return retval;
+}

rcts/rc_rmcd/src/Database.h

@@ -0,0 +1,56 @@
+/***************************************************************************
+                Database Class
+                -----------------------------------------
+    begin      : 2010/03/11
+    copyright  : (C) 2010 SolutionBox Inc.
+	author     : Service 1 Team
+	email      : svc1@solbox.com
+    version    : 1.0
+
+    CopyRight(C) 2010 SolutionBox Inc. All Rights reserved.
+    Redistribution and use in source and binary forms, with or with out
+    modification, are not permitted in outside of SolutionBox Inc.
+***************************************************************************/
+#ifndef __DATABASE_H__
+#define __DATABASE_H__
+
+#include <iostream>
+#include <string>
+
+#include "libpq-fe.h"
+#define MaxSizeOfDBQuery		1024*9
+
+using namespace std;
+class DataBase
+{
+public:
+	enum CFLAG { CLEAR = 1, NOT_CLEAR };
+	DataBase() { m_PGconn = NULL; m_pRes = NULL;}
+	~DataBase();
+	PGconn *PgOpenDB(string &strHost, int Port, string &strDBName, string &strAcct, string &strPasswd, int timeout = 10);
+	PGconn *PgOpenDB(const char *pszDBName);
+	void PgCloseDB();
+	int PgResult(CFLAG flag);
+	PGconn *GetPgConn(){ return m_PGconn;}
+	PGresult *GetRes();
+	void SetRes(PGresult * v) {m_pRes = v;}
+	int GetCmdTuples();
+	int GetNoTuples();
+	int GetNoFields();
+	int GetResultCode() { return m_ResultCode; }
+	char *GetValue(int tuple, int field);
+	void PgClear();
+	int PgDoExec(string &strQuery);
+	int PgDoExec(char *pszQuery);
+	int PgDoExec(char *pszQuery, CFLAG flag);
+	int PgDoExecParams(char *pszQuery, int nParamCnt, const char * const *paramValues ,CFLAG flag = NOT_CLEAR);
+	int PgEscapeString(char *to, const char *from, size_t length);
+	string &GetErrorMessage();
+private:
+	int m_ResultCode;
+	PGconn *m_PGconn;
+	PGresult *m_pRes;
+	string m_ErrorMessage;
+};
+
+#endif // ~__DATABASE_H__

rcts/rc_rmcd/src/FimngdSocketControl.cpp

@@ -0,0 +1,188 @@
+#include "FimngdSocketControl.h"
+
+#include "Logger.h"
+
+#include <arpa/inet.h>
+
+// Packet Header stx 코드
+#define HEADER_STX_CODE					0x02
+
+// Packet Header type 구분코드
+#define HEADER_TYPE_REQUEST				0x00
+
+// Packet command : fimngd 요청 ( Command 3th Byte 만 사용 )
+#define REQUEST_CACHE_CREATE            0x01
+
+
+// 생성자.
+// param [IN] clientSocket client 와 통신 연결된 socket.
+CFimngdSocketControl::CFimngdSocketControl( int clientSocket )
+	: CBaseSocket( clientSocket )
+	  , m_nPacketHeaderLen ( sizeof(m_packetHeader))
+	  , m_nPacketDataLen( 0 )
+{
+}
+
+// 소멸자.
+CFimngdSocketControl::~CFimngdSocketControl()
+{
+	// 소멸자 Socket 명시적 Close 처리.
+	Close();
+}
+
+// 수신된 Data 를 전달받은 인자에 설정하여 반환 처리
+// @param [OUT] data 수신된 Data 를 저장할 객체에 대한 참조
+// @param [in] timeout 대기 timeout (sec)
+// @return  -1 : Socket 오류 또는 잘못된 Data 수신시
+//           0 : timeout 발생시
+//           1 : 정상
+int CFimngdSocketControl::GetData( CCacheRequestData & data, int timeout )
+{
+	// Header 정보를 수신
+	int nResult = GetPacketHeader( timeout );
+	
+	if( nResult == -1 )
+	{
+		// Socket 끊김 또는 정의되지 않은 Data 수신시.
+		return -1;
+	}
+	else if( nResult == 0 )
+	{
+		// timeout 발생시
+		return 0;
+	}
+
+	// Header Data 정상 수신시... command code 에 따른 처리.	
+	if( m_packetHeader.command[2] == REQUEST_CACHE_CREATE )
+	{
+		// Cache 생성 요청인 경우...
+
+		// Body 부분이 고정 Packet 형식이므로....
+		// - 수신된 data_length 와 이를 저장할 구조체의 크기가 동일한지 확인
+		// - 만약 동일하지 않은 경우.. packet 오류로 처리
+		if( m_nPacketDataLen != sizeof( struct stCacheRequestBody ) )
+		{
+			LOG( LERR, "Cache request packet body size not valid.[%u]/[%lu]"
+				, m_nPacketDataLen, sizeof( struct stCacheRequestBody ) );
+			return -1;
+		}
+
+		// Data 부분 수신 처리.
+		if( GetBodyCacheRequest( data ) == false )
+		{
+			// body 수신 처리시 오류 발생			
+			return -1;
+		}
+		
+		return 1;		
+	}
+	else
+	{
+		// 미정의된 command code 인 경우( 현재 1개 type 만 정의되어 있으므로. )
+		LOG( LERR, "Not defined command code." );
+		PrintHeaderToLog();
+		return -1;
+	}
+}
+
+
+// Packet Header 정보를 Log 파일에 Logging 처리 ( Debug 처리를 위한 함수)
+void CFimngdSocketControl::PrintHeaderToLog()
+{
+
+	_LOG( LINF, "------------------------------------" );
+	_LOG( LINF, "stx         [%02x]", m_packetHeader.stx );
+	_LOG( LINF, "type        [%02x]", m_packetHeader.type );
+	_LOG( LINF, "command     [%02x][%02x][%02x][%02x]" , m_packetHeader.command[0], m_packetHeader.command[1] , m_packetHeader.command[2], m_packetHeader.command[3] );
+	_LOG( LINF, "result      [%02x][%02x][%02x][%02x]" , m_packetHeader.result[0], m_packetHeader.result[1] , m_packetHeader.result[2], m_packetHeader.result[3] );
+	_LOG( LINF, "data_length [%u]", m_nPacketDataLen );
+	_LOG( LINF, "extend_code [%02x][%02x]", m_packetHeader.extend_code[0], m_packetHeader.extend_code[1] );
+
+	_LOG( LINF, "------------------------------------" );
+}
+
+// Packet Header 부분의 수신 처리를 위한 함수
+// @param timeout [in] 대기시간.
+// @retrun 0 : timeout
+//         1 : 성공
+//        -1 : socket 오류 또는 정의된 Data 가 아닌 경우.
+int CFimngdSocketControl::GetPacketHeader( int timeout )
+{
+	if( IsValidSocket() == false )
+		return -1;
+
+	// Socket 으로 부터 Packet Header 부분 수신.
+	// 수신된 정보는 멤버변수에 저장처리.
+	/// read 된 데이터의 크기. 0: fd closed, -1: 오류, -2: Timeout
+	int nRead = ReadNTimeout( &m_packetHeader, m_nPacketHeaderLen, timeout );
+		
+	if( nRead == -2 )
+	{
+		// timeout 발생시
+		return 0;
+	}
+	else if( nRead <= 0 )
+	{
+		// timeout 을 제외한 그 밖의 오류 발생시
+		return -1;
+	}
+	else
+	{
+		// 정상 Data 수신시.
+		
+		// STX code 검사.
+		if( m_packetHeader.stx != HEADER_STX_CODE )
+		{
+			LOG( LERR, "Not valid stx code." );
+			PrintHeaderToLog();
+			return -1;
+		}
+
+		// Type Code 검사
+		if( m_packetHeader.type != HEADER_TYPE_REQUEST )
+		{
+			LOG( LERR, "Not valid type code." );
+			PrintHeaderToLog();
+			return -1;
+		}
+		
+		// Data Length 부분 값을 멤버 변수에 저장처리.
+		m_nPacketDataLen = ntohl( m_packetHeader.data_length );
+
+		return 1;
+	}
+}
+
+
+// FHS 의 Hot Content Cache 생성 요청 Packet Body 부분을 수신 처리
+bool CFimngdSocketControl::GetBodyCacheRequest( CCacheRequestData & data )
+{
+	// 수신된 Body 를 저장할 변수 생성.
+	struct stCacheRequestBody stBody;
+
+	// Body 부분 수신 처리.
+	int nRead = ReadNTimeout( &stBody, m_nPacketDataLen, 15 );
+	
+	if( nRead == -2 )
+	{
+		// timeout 발생시
+		// - 지정된 시간 동안 Header 에 기록된 Body 크기를 읽지 못했으므로. 오류로 처리
+		LOG( LERR, "cache request body[%lu] read timeout.", sizeof( struct stCacheRequestBody ) );
+		return false;
+	}
+	else if( nRead <= 0 )
+	{
+		// timeout 을 제외한 그 밖의 오류 발생시
+		LOG( LERR, "cache request body read error[%d]", nRead );
+		return false;
+	}
+	else
+	{
+		// Body 부분 정상 수신시...
+		// - 수신된 Data 를 파싱하여....
+		// - 인자로 전달받은 data 객체에 저장 처리.
+		data.Set( &stBody );
+		
+		return true;
+	}
+}

rcts/rc_rmcd/src/FimngdSocketControl.h

@@ -0,0 +1,98 @@
+/***************************************************************************
+                fimngd socket control class
+                -----------------------------------------
+	begin      : 2014/07/04
+	copyright  : (C) 2005 Solbox Inc.
+	author     : Storage Dev Team
+	email      : storage.sd@solbox.com
+	version    : 3.3
+
+	CopyRight(C) 2005 Solbox Inc. All Rights reserved.
+	Redistribution and use in source and binary forms, with or with out
+	modification, are not permitted in outside of Solbox Inc.
+***************************************************************************/
+
+
+#ifndef __FIMNGD_SOCKET_CONTROL_H__
+#define __FIMNGD_SOCKET_CONTROL_H__
+
+#include "BaseSocket.h"
+#include "CacheRequestData.h"
+
+
+///< BYTE 타입 정의
+#ifndef _BYTE_DEFINED
+#define _BYTE_DEFINED
+typedef unsigned char BYTE;
+#endif  // _BYTE_DEFINED
+
+// fimngd 와의 통신 관련 Packet Header
+// - 계산상 크기는 16Byte 이지만...
+// - 통신상 sizeof() : 20Byte ( 64Bit OS )
+struct stFimngdPacketHeader {
+
+	char stx;					// Packet 유효성 관리 코드
+	char type;					// Request or Response 여부 ( 0x00: Request, 0x01: Response )
+	char command[4];			// Command Code ( 4 Byte) : 3th 0x01 설정
+	char result[4];				// Result Code  ( 4 Byte )
+	unsigned int  data_length;	// Packet Data 부분의 길이값 ( Network Byte Order 사용)
+	char extend_code[2];		// 확장 및 Padding bits ( 2 Byte )
+};
+
+
+// CFimngdSocketControl
+// FHS 의 fimngd 로 부터 Hot Content 정보 수신 처리를 담당할 Socket 처리 Class
+class CFimngdSocketControl : public CBaseSocket
+{
+
+	public:
+
+		// 생성자.
+		// @param [IN] clientSocket client 와 통신 연결된 socket.
+		CFimngdSocketControl( int clientSocket );
+		
+		// 소멸자.
+		~CFimngdSocketControl();
+		
+		// 수신된 Data 를 전달받은 인자에 설정하여 반환 처리
+		// @param [OUT] data 수신된 Data 를 저장할 객체에 대한 참조
+		// @param [in] timeout 대기 timeout (sec)
+		// @return  -1 : Socket 오류 또는 잘못된 Data 수신시
+		//           0 : timeout 발생시
+		//           1 : 정상
+		int GetData( CCacheRequestData & data, int timeout = DEFAULT_DATA_RECEIVE_TIMEOUT );
+		
+
+
+	private:
+		
+		// Packet Header 변수
+		struct stFimngdPacketHeader m_packetHeader;
+
+		// m_packetHeader 구조체의 크기를 저장하기 위한 상수
+		const int m_nPacketHeaderLen;
+		
+		// Packet Header 에 저장된 Data 부분의 길이 정보값.
+		unsigned int m_nPacketDataLen;
+		
+
+	protected:
+
+		// Packet Header 정보를 Log 파일에 Logging 처리 ( Debug 처리를 위한 함수)
+		void PrintHeaderToLog( void );
+
+		// Packet Header 부분의 수신 처리를 위한 함수
+		// @param timeout [in] 대기시간.
+		// @retrun 0 : timeout
+		//         1 : 성공
+		//        -1 : socket 오류 또는 정의된 Data 가 아닌 경우.
+		int GetPacketHeader( int timeout = DEFAULT_DATA_RECEIVE_TIMEOUT );
+
+		// FHS 의 Hot Content Cache 생성 요청 Packet Body 부분을 수신 처리
+		bool GetBodyCacheRequest( CCacheRequestData & data );
+
+		
+};
+
+#endif /* __FIMNGD_SOCKET_CONTROL_H__ */
+

rcts/rc_rmcd/src/FtsdProtocol.h

@@ -0,0 +1,64 @@
+/***************************************************************************
+      ftsd control interface ( File Replication & Cache & Move & Delete Control) Header ( FtsdProtocol.h )
+                -----------------------------------------
+	begin      : 2010/03/09
+	copyright  : (C) 2005 SolutionBox Inc.
+	author     : Service 1 Team
+	email      : svc1@solbox.com
+	version    : 3.2.0.R0811
+
+	CopyRight(C) 2005 SolutionBox Inc. All Rights reserved.
+	Redistribution and use in source and binary forms, with or with out
+	modification, are not permitted in outside of SolutionBox Inc.
+***************************************************************************/
+
+#ifndef __FTSD_PROTOCOL_H__
+#define __FTSD_PROTOCOL_H__
+
+
+struct FileTransferPacketHeader {
+
+	char stx;					// Packet 유효성 관리 코드
+	char type;					// Request or Response 여부 ( 0x00: Request, 0x01: Response )
+	char command[4];			// Command Code ( 4 Byte) : 0th control-ftsd, 1th ftsd-ftsd 사용.
+	char result[4];				// Result Code  ( 4 Byte )
+	unsigned int  data_length;	// Packet Data 부분의 길이값 ( Network Byte Order 사용)
+	char extend_code[2];		// 확장 및 Padding bits ( 2 Byte )
+};
+
+
+// Packet Header stx 코드
+#define HEADER_STX_CODE					0x02
+
+// Packet Header type 구분코드
+#define HEADER_TYPE_REQUEST				0x00
+#define HEADER_TYPE_RESPONSE			0x01
+
+
+// Packet command 공통.
+#define COMMON_ALIVE_CHECK				0x7F
+
+// Packet command :  control 프로세스 <-> ftsd 통신 ( Command 첫번째 Byte 만 사용 )
+#define NOT_CONTROL_COMMAND				0x00	// Control 이 전송한 요청이 아닌 경우.
+#define CONTROL_FILE_REPLICATION		0x01	// Content 복제 생성 요청
+#define CONTROL_FILE_CACHE				0x02	// Content 에 대해 Cache 폴더로 복제 요청
+
+#define CONTROL_FILE_CHECK              0x03	// Content 에 대한 존재 여부, Size 확인 및 Hash 추출 요청
+#define CONTROL_FILE_UNLINK             0x04	// Content 에 대한 unlink 처리 요청
+
+
+// Packet Result : type이 Reponse 인 경우에만 세팅됨.( 첫번째 Byte 만 사용시 )
+#define HEADER_RESULT_SUCCESS			0x00
+#define HEADER_RESULT_ERROR				0x01
+
+
+// 기타 정보
+#define LENGTH_FIELD_SIZE				4		// 가변데이터 형식 사용시 Length 필드의 메모리 크기 (unsigned int)
+
+
+// unlink 요청시 Mode 설정 정보
+#define UNLINK_MODE_NORMAL				0		// 해당 Content 가 존재하고 size 값이 정확한 경우에만 삭제, 나머지는 오류
+#define UNLINK_MODE_FORCE				1		// 해당 Content 가 존재하지 않거나.. Size 값이 틀려도 강제로 삭제 처리.. 오류로 처리되는 상황은 통신, 시스템 오류 발생시.
+
+
+#endif /* __FTSD_PROTOCOL_H__ */

rcts/rc_rmcd/src/FtsdSocketControl.h

@@ -0,0 +1,263 @@
+/***************************************************************************
+    ftsd control interface ( File Replication & Cache & Move & Delete Control) Header ( FtsdSocketControl.h )
+                -----------------------------------------
+	begin      : 2010/03/09
+	copyright  : (C) 2005 SolutionBox Inc.
+	author     : Service 1 Team
+	email      : svc1@solbox.com
+	version    : 3.2.0.R0811
+
+	CopyRight(C) 2005 SolutionBox Inc. All Rights reserved.
+	Redistribution and use in source and binary forms, with or with out
+	modification, are not permitted in outside of SolutionBox Inc.
+***************************************************************************/
+
+#ifndef __FTSD_SOCKET_CONTROL_H__
+#define __FTSD_SOCKET_CONTROL_H__
+
+#include "BaseSocket.h"
+#include "FtsdProtocol.h"
+
+#include <iostream>
+#include <vector>
+#include <map>
+
+
+///< BYTE 타입 정의
+#ifndef _BYTE_DEFINED
+#define _BYTE_DEFINED
+typedef unsigned char BYTE;
+#endif  // _BYTE_DEFINED
+
+
+#define DEFAULT_SOCKET_TEMP_BUFFER_SIZE		1024	// SocketControl 에서 사용할 임시버퍼 크기.
+
+class CFtsdSocketControl : public CBaseSocket
+{
+	private:
+		
+		/// @brief Packet Header 변수
+		struct FileTransferPacketHeader m_packetHeader;
+
+		/// @brief m_packetHeader 구조체의 크기를 저장하기 위한 상수
+		const int m_nPacketHeaderLen;  
+
+		/// @brief Packet Header 에 저장된 Data 부분의 길이 정보값.
+		unsigned int m_nPacketDataLen;
+
+		/// @brief Packet Data 부분의 수신처리시 임시로 사용할 버퍼.
+		BYTE m_tempBuffer[DEFAULT_SOCKET_TEMP_BUFFER_SIZE];
+
+
+	public:
+
+		/// @brief 생성자.
+		CFtsdSocketControl();
+		
+		/// @brief 소멸자.
+		~CFtsdSocketControl();
+
+
+		/// @brief 전달받은 Target 으로 Socket 접속을 수행
+		/// @param szTarget [in] 접속 대상 Host name 또는 IP
+		/// @param nPort	[in] 접속 Port
+		/// @return 접속 성공시 true, 실패시 false 반환. ( 오류 내역은 로깅처리됨.)
+		bool ConnectTarget( const std::string& szTarget, int nPort );
+	
+
+		/// @brief 대상과 연결된 Socket 을 통해 ftsd 로 File Replication 명령 전송.
+		/// @param szFileName [in] 복제할 원본 Source 파일명 (/stg/node0/186/abcde..)
+		/// @param nFileSize  [in] 복제할 원본 Source 파일의 크기.
+		/// @param szTargetTranId [in] RC 간 복제 처리시 변경할 대상 Tran ID 정보 값.
+		/// @param nFileHashCheckLevel [in] File 에 대한 Hash Check Level 정보 ( conf 파일에 지정됨)
+		/// @param bUseInternalIp [in] 내부망을 이용하여 파일 송수신을 수행할지 여부 \n
+		///<                      해당값을 true 로 지정시 ftsd 상에서 내부망을 우선 사용하여 파일 복제 시도
+		///<                      만약 내부망 사용 불가시 자동으로 외부망 사용.
+		///<                      RC-RC 간 처리시에는 사용하지 않도록 false 로 지정할 것.
+		/// @param vecTargetFhs [in] 복제 대상 Target FHS Host Name 정보
+		/// @return Replication 복제 요청 메시지 전송 성공시 true, 실패시 false 반환.
+		bool SendFileReplicationRequest(const std::string& szFileName, unsigned long long nFileSize, int nFileHashCheckLevel, bool bUseInternalIp, std::vector< std::string >& vecTargetFhs);
+		bool SendFileReplicationRequest(const std::string& szFileName, unsigned long long nFileSize, const std::string& szTargetTranId, int nFileHashCheckLevel, bool bUseInternalIp, std::vector< std::string >& vecTargetFhs);
+
+
+		/// @brief File Replication 요청에 대한 처리 결과를 ftsd 로 부터 수신한다. 
+		/// @param nTimeout [in] 함수 호출에 대한 Blocking 을 방지하기 위한 Timeout 설정값. 단위( second )\n
+		///<                     지정된 시간동안 응답을 수신하지 못한 경우 0 을 반환.
+		/// @param bSuccess [out] File Replication 이 정상적으로 수행되었는지 여부 \n
+		///<                      trnsfer 상에서 오류가 발생한 경우 이 값은 false 가 되며 \n
+		///<                      szErrorMessage 변수상에 오류내용이 저장됨. \n
+		///<                      정상적으로 처리된 경우 true 가 저장되며 \n
+		///<                      mapSuccessFhs, mapFailFhs 상에 관련 정보가 저장됨.
+		/// @param szErrorMessage [out] bSuccess == false 인 경우 발생된 오류메시지 정보를 저장
+		/// @param mapSuccessFhs [out] bSuccess == true 인 경우 \n
+		///<                           Replication 처리에 성공한 FHS 및 저장된 File 이름 정보를 저장
+		/// @param mapFailFhs [out] bSuccess == true 인 경우 \n
+		///<                        Replication 처리에 실패한 FHS Host Name 및 발생된 오류메시지 정보를 저장.
+		///
+		/// @return -1 : Socket 통신 관련 오류 발생하여 ftsd 와 연결이 끊어진 경우 \n
+		///<             => ftsd 와 연결이 끝어진것으로 판단하고 오류처리한다. \n
+		///<
+		///<         0 : 입력변수인 nTimeout 에 지정된 시간안에 ftsd 로부터
+		///<             Replication 에 대한 처리 결과 정보를 수신하지 못한 경우. \n
+		///<             이 기능은 본 함수 호출시 Blocking 발생을 막기 위한 기능으로서 \n
+		///<             이 값이 반환된 경우 추가 다른 작업을 진행한 후 본 함수를 다시 호출하여 \n
+		///<             응답을 대기할 수 있다. \n
+		///<
+		///<         1 : 파일 복제 처리에 대한 응답을 수신한 경우, Output 인자인 bSuccess 를 확인하여 처리 결과 확인
+		///<             
+		///<         2 : ftsd 로 부터 Data 을 수신하였으나 File Replication 요청에 대한 응답이 아닌 경우 \n
+		///<             해당 정보는 본 클래스의 멤버변수 상에 내부적으로 저장된다. ( 단 Alive Packet 은 아님) \n
+		///<             본 결과가 수신된 경우 무시 처리하고 계속 응답을 대기하면 된다.
+		int GetFileReplicationResult( int nTimeout, bool& bSuccess, std::string& szErrorMessage, std::map< std::string, std::string>& mapSuccessFhs, std::map< std::string, std::string>& mapFailFhs );
+
+
+		/// @brief 대상과 연결된 Socket 을 통해 ftsd 로 File Cache 명령 전송.
+		/// @param szFileName [in] Cache 처리할 원본 Source 파일명 (/stg/node0/186/abcde..)
+		/// @param nFileSize  [in] Cache 처리할 원본 Source 파일의 크기.
+		/// @param nFileHashCheckLevel [in] File 에 대한 Hash Check Level 정보 ( conf 파일에 지정됨)
+		/// @param bUseInternalIp [in] 내부망을 이용하여 파일 송수신을 수행할지 여부 \n
+		///<                      해당값을 true 로 지정시 ftsd 상에서 내부망을 우선 사용하여 파일 복제 시도
+		///<                      만약 내부망 사용 불가시 자동으로 외부망 사용.
+		/// @param vecTargetFhs [in] Cache 대상 Target FHS Host Name 정보
+		/// @return Cache 요청 메시지 전송 성공시 true, 실패시 false 반환.
+		bool SendFileCacheRequest(const std::string& szFileName, unsigned long long nFileSize, int nFileHashCheckLevel, bool bUseInternalIp, std::vector< std::string >& vecTargetFhs);
+
+
+		/// @brief File Cache 요청에 대한 처리 결과를 ftsd 로 부터 수신한다. 
+		/// @param nTimeout [in] 함수 호출에 대한 Blocking 을 방지하기 위한 Timeout 설정값. 단위( second )\n
+		///<                     지정된 시간동안 응답을 수신하지 못한 경우 0 을 반환.
+		/// @param bSuccess [out] File Cache 처리가 정상적으로 수행되었는지 여부 \n
+		///<                      trnsfer 상에서 오류가 발생한 경우 이 값은 false 가 되며 \n
+		///<                      szErrorMessage 변수상에 오류내용이 저장됨. \n
+		///<                      정상적으로 처리된 경우 true 가 저장되며 \n
+		///<                      mapSuccessFhs, mapFailFhs 상에 관련 정보가 저장됨.
+		/// @param szErrorMessage [out] bSuccess == false 인 경우 발생된 오류메시지 정보를 저장
+		/// @param mapSuccessFhs [out] bSuccess == true 인 경우 \n
+		///<                           Cache 처리에 성공한 FHS 및 저장된 File 이름 정보를 저장
+		/// @param mapFailFhs [out] bSuccess == true 인 경우 \n
+		///<                        Cache 처리에 실패한 FHS Host Name 및 발생된 오류메시지 정보를 저장.
+		///
+		/// @return -1 : Socket 통신 관련 오류 발생하여 ftsd 와 연결이 끊어진 경우 \n
+		///<             => ftsd 와 연결이 끝어진것으로 판단하고 오류처리한다. \n
+		///<
+		///<         0 : 입력변수인 nTimeout 에 지정된 시간안에 ftsd 로부터
+		///<             Cache 에 대한 처리 결과 정보를 수신하지 못한 경우. \n
+		///<             이 기능은 본 함수 호출시 Blocking 발생을 막기 위한 기능으로서 \n
+		///<             이 값이 반환된 경우 추가 다른 작업을 진행한 후 본 함수를 다시 호출하여 \n
+		///<             응답을 대기할 수 있다. \n
+		///<
+		///<         1 : 파일 Cache 처리에 대한 응답을 수신한 경우, Output 인자인 bSuccess 를 확인하여 처리 결과 확인
+		///<             
+		///<         2 : ftsd 로 부터 Data 을 수신하였으나 File Cache 요청에 대한 응답이 아닌 경우 \n
+		///<             해당 정보는 본 클래스의 멤버변수 상에 내부적으로 저장된다. ( 단 Alive Packet 은 아님) \n
+		///<             본 결과가 수신된 경우 무시 처리하고 계속 응답을 대기하면 된다.
+		int GetFileCacheResult( int nTimeout, bool& bSuccess, std::string& szErrorMessage, std::map< std::string, std::string>& mapSuccessFhs, std::map< std::string, std::string>& mapFailFhs );
+
+		
+		/// @brief 대상과 연결된 Socket 을 통해 ftsd 로 Content Check 명령 전송.
+		/// @param szFileName [in] 원본 Source 파일명 (/stg/node0/186/abcde..)
+		/// @param bHashCheck [in] Hash 값을 추출할지 여부
+		/// @param nHashCheckSize [in] Hash 값을 추출할 경우 Size 설정값 ( MByte 단위 )\n
+		///<                          0    : Content 에 대한 전체 Hash 값을 추출함.
+		///<                          숫자 : Content 의 앞 부분부터 지정된 크기 (MByte ) 까지 Hash 값을 추출
+		/// @return Check 요청 메시지 전송 성공시 true, 실패시 false 반환.
+		bool SendFileCheckRequest(const std::string& szFileName, bool bHashCheck, unsigned long long nHashCheckSize );
+
+		/// @brief File Check 요청에 대한 처리 결과를 ftsd 로 부터 수신한다. 
+		/// @param nTimeout [in] 함수 호출에 대한 Blocking 을 방지하기 위한 Timeout 설정값. 단위( second )\n
+		///<                     지정된 시간동안 응답을 수신하지 못한 경우 0 을 반환.
+		/// @param bSuccess [out] File Check 처리가 정상적으로 수행되었는지 여부 \n
+		///<                      ftsd 상에서 오류가 발생한 경우 이 값은 false 가 되며 \n
+		///<                      szErrorMessage 변수상에 오류내용이 저장됨. \n
+		///<                      정상적으로 처리된 경우 true 가 저장되며 \n
+		///<                      nFileSize, szHashValue 상에 결과 정보가 저장됨.
+		/// @param szErrorMessage [out] bSuccess == false 인 경우 발생된 오류메시지 정보를 저장
+		/// @param nFileSize      [out] bSuccess == true 인 경우 요청한 Content 에 대한 file size 정보를 저장. ( Byte 단위 )
+		/// @param szHashValue    [out] bSuccess == true 이고... Hash 값 추출을 요청한 경우 추출된 Hash 값 정보를 저장.
+		/// @return -1 : Socket 통신 관련 오류 발생하여 ftsd 와 연결이 끊어진 경우 \n
+		///<             => ftsd 와 연결이 끝어진것으로 판단하고 오류처리한다. \n
+		///<
+		///<         0 : 입력변수인 nTimeout 에 지정된 시간안에 ftsd 으로부터 처리 결과 정보를 수신하지 못한 경우. \n
+		///<             이 기능은 본 함수 호출시 Blocking 발생을 막기 위한 기능으로서 \n
+		///<             이 값이 반환된 경우 추가 다른 작업을 진행한 후 본 함수를 다시 호출하여 \n
+		///<             응답을 대기할 수 있다. \n
+		///<
+		///<         1 : 파일 Check 처리에 대한 응답을 수신한 경우, Output 인자인 bSuccess 를 확인하여 처리 결과 확인
+		///<             
+		///<         2 : ftsd 으로 부터 Data 을 수신하였으나 File Check 요청에 대한 응답이 아닌 경우 \n
+		///<             해당 정보는 본 클래스의 멤버변수 상에 내부적으로 저장된다. ( 단 Alive Packet 은 아님) \n
+		///<             본 결과가 수신된 경우 무시 처리하고 계속 응답을 대기하면 된다.
+		int GetFileCheckResult( int nTimeout, bool& bSuccess, std::string& szErrorMessage, unsigned long long& nFileSize, std::string& szHashValue );
+
+
+		/// @brief 대상과 연결된 Socket 을 통해 ftsd 로 Unlink 명령 전송.
+		/// @param szFileName   [in] 원본 Source 파일명 (/stg/node0/186/abcde..)
+		/// @param nFileSize    [in] 원본 파일의 크기 ( Byte 단위 )
+		/// @param bForceUnlink [in] 강제 삭제 처리 여부 ( Defalult false )
+		///                      false : 일반모드 - 해당 파일이 존재하고 Size 값이 동일할 경우에만 삭제처리.. 나머지는 오류로 처리.
+		///                      true  : 강제모드 - 해당 파일이 존재하지 않거나.. Size 가 틀려도 강제로 삭제 처리.. 오류는 통신, 시스템 오류 발생시에만
+		/// @return Unlink 요청 메시지 전송 성공시 true, 실패시 false 반환.
+		bool SendFileUnlinkRequest(const std::string& szFileName, unsigned long long nFileSize, bool bForceUnlink = false );
+
+		/// @brief File Unlink 요청에 대한 처리 결과를 ftsd 로 부터 수신한다. 
+		/// @param nTimeout [in] 함수 호출에 대한 Blocking 을 방지하기 위한 Timeout 설정값. 단위( second )\n
+		///<                     지정된 시간동안 응답을 수신하지 못한 경우 0 을 반환.
+		/// @param bSuccess [out] File unlink 처리가 정상적으로 수행되었는지 여부 \n
+		///<                      ftsd 상에서 오류가 발생한 경우 이 값은 false 가 되며 \n
+		///<                      szErrorMessage 변수상에 오류내용이 저장됨. \n
+		///<                      정상적으로 처리된 경우 true 가 저장되며 따로 수신하는 Data 는 없음. \n
+		/// @param szErrorMessage [out] bSuccess == false 인 경우 발생된 오류메시지 정보를 저장
+		/// @return -1 : Socket 통신 관련 오류 발생하여 ftsd 와 연결이 끊어진 경우 \n
+		///<             => ftsd 와 연결이 끝어진것으로 판단하고 오류처리한다. \n
+		///<
+		///<         0 : 입력변수인 nTimeout 에 지정된 시간안에 ftsd 으로부터 처리 결과 정보를 수신하지 못한 경우. \n
+		///<             이 기능은 본 함수 호출시 Blocking 발생을 막기 위한 기능으로서 \n
+		///<             이 값이 반환된 경우 추가 다른 작업을 진행한 후 본 함수를 다시 호출하여 \n
+		///<             응답을 대기할 수 있다. \n
+		///<
+		///<         1 : 파일 Unlink 처리에 대한 응답을 수신한 경우, Output 인자인 bSuccess 를 확인하여 처리 결과 확인
+		///<             
+		///<         2 : ftsd 으로 부터 Data 을 수신하였으나 File Unlink 요청에 대한 응답이 아닌 경우 \n
+		///<             해당 정보는 본 클래스의 멤버변수 상에 내부적으로 저장된다. ( 단 Alive Packet 은 아님) \n
+		///<             본 결과가 수신된 경우 무시 처리하고 계속 응답을 대기하면 된다.
+		int GetFileUnlinkResult( int nTimeout, bool& bSuccess, std::string& szErrorMessage );
+
+		
+		/// @brief 연결된 Socket 통신을 이용하여 내부적으로 정의된 Alive Check 패킷 전송 \n
+		///<       => 해당 패킷에 대한 처리는 내부적으로 처리되어 결과값을 확인할 필요는 없다.
+		/// @return Socket 연결 해제 또는 전송 관련 오류 발생시 false, 전송 성공시에는 true 반환.
+		bool SendAliveCheck(void);
+		
+		/// @brief Packet Header 정보를 Log 파일에 Logging 처리 ( Debug 처리를 위한 함수)
+		void PrintHeaderToLog(void);
+
+
+	protected:
+		
+		/// @brief Packet Header 부분의 수신 처리를 위한 함수. Alive Check 요청 패킷은 자동으로 무시처리함.
+		/// @param timeout [in] 대기시간.
+		/// @retrun 성공시 true, 오류 발생및 실패시 fasle 반환.
+		bool GetPacketHeader(int timeout = DEFAULT_DATA_RECEIVE_TIMEOUT);
+
+		/// @brief socket 에서 지정된 크기만큼의 데이터를 읽어 출력변수에 저장처리.
+		/// @param size [in] read 할 데이터 크기
+		/// @param value [out] 읽은 데이터를 저장할 string 변수
+		/// @return On success return true, otherwise return false.
+		bool GetPacketData( unsigned int& size, std::string& value );
+
+		/// @brief socket 에서 지정된 크기만큼의 데이터를 읽어 내부 임시버퍼인 m_tempBuffer 에 저장처리.
+		/// @param size [in] read 할 데이터 크기
+		/// @return On success return true, otherwise return false.
+		bool GetPacketData( unsigned int size );
+
+		/// @brief pValue 에 저장된 데이터를 unsigned int 형으로 변환처리 및 Endian 변환
+		unsigned int GetDataToUInt( BYTE * pValue, bool bConvertEndian = true );
+
+		/// @brief pValue 에 저장된 데이터를 unsigned long long (64Byte) 형으로 변환처리.
+		unsigned long long GetDataToUInt64( BYTE * pValue );
+
+
+};
+
+#endif /* __FTSD_SOCKET_CONTROL_H__ */
+

rcts/rc_rmcd/src/Main.cpp

@@ -0,0 +1,510 @@
+#include "Main.h"
+
+#include "ProcessRename.h"
+#include "ServiceConfig.h"
+#include "Logger.h"
+#include "Worker.h"
+
+#include <unistd.h>
+#include <stdio.h>
+#include <errno.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <string.h>
+#include <stdlib.h>
+#include <time.h>
+
+
+// Accept 대기 Count 수
+#define DEFAULT_ACCEPT_WAIT_COUNT	50
+
+// 전역 객체 정보
+// Hot Content 생성 관련 fimngd로 부터 정보 수신을 위한 TCP Listen Socket
+int g_listenHotContentSocket = -1;
+
+
+// 사용방법 표시
+void PrintUsage()
+{
+	fprintf(stderr, "\n");
+	fprintf(stderr, "Usage: " PROG_NAME " [-h] [-v] [-c {file}]            \n");
+	fprintf(stderr, "Options:                                              \n");
+	fprintf(stderr, "  -h                       Display help information   \n");
+	fprintf(stderr, "  -v                       Display version            \n");
+	fprintf(stderr, "  -c {file}                Use {file} as config file  \n");
+
+	fprintf(stderr, "\n");
+	fprintf(stderr, PROG_NAME " is Solbox Cloud Storage module that control content replication, hot content cache flow.\n\n");
+
+	return;
+}
+
+// 버전 정보 표시
+void PrintVersion()
+{
+	fprintf(stderr, "\n");
+	fprintf(stderr, PROG_NAME " version: " PROG_VERSION "\n\n");
+
+	return;
+}
+
+
+int main( int argc, char * argv[] )
+{
+	// 설정 파일을 저장할 변수.
+	std::string strConfigFileName = DEFAULT_CONFIG_FILE;
+	
+	// linux 에서 프로세스를 Titile 변경을 지원을 위해서 argv 메모리에 저장
+	argv = save_ps_display_args(argc, argv);
+	
+	// 전달 받은 옵션 여부 확인 및 처리
+	if( argc >= 2)
+	{
+		int opt;
+		while((opt = getopt(argc, argv, "hvc:")) != -1)	// 옵션 끝까지 파싱처리
+		{
+			switch(opt)
+			{
+			case 'h':
+			case '?':	// 정의되지 않은 문자가 나타날 경우 getopt 에 자동반환. 도움말 표시 처리. 
+				PrintUsage();
+				return EXIT_SUCCESS;
+
+			case 'v':
+				PrintVersion();
+				return EXIT_SUCCESS;
+
+			case 'c':
+				strConfigFileName = optarg;
+				fprintf(stderr, PROG_NAME " start with user define conf[%s]\n", strConfigFileName.c_str());
+				break;
+
+			default:	// 본 조건절은 getopt 특성상 동작하지 않지만...업무 Flow 이해(?)를 위해 유지한다.
+				fprintf(stderr, "Unkonwn options[%c] used. program terminated.\n", opt);
+				return EXIT_FAILURE;
+			}
+		}
+	}
+		
+	// 프로그램 중복 실행 체크
+	if( IsCurrentProcessRun() == true )
+	{
+		fprintf(stderr, "[warning] Process[" PROG_NAME "] is already running...\n");		
+		return EXIT_FAILURE;
+	}
+
+	// conf 로딩 및 검사	
+	std::string szErrorMessage;
+	if( CServiceConfig::Init( PROG_NAME, strConfigFileName, szErrorMessage ) == false)
+	{
+		fprintf(stderr, "[ERR] %s\n\n", szErrorMessage.c_str());
+		return EXIT_FAILURE;
+	}
+
+	// Log 객체 생성 및 초기화
+	if( CLogger::Init( PROG_NAME, CServiceConfig::GetInstance()->GetLogPath(), LINF ) == false)
+	{
+		fprintf(stderr, "[ERR] Log module initialize failed.[%s]\n\n", CServiceConfig::GetInstance()->GetLogPath());
+		return EXIT_FAILURE;
+	}
+
+	// Daemonize...
+	// - nochdir: true(작업 디렉토리 변경 안함)
+	// - noclose: false (표준 입출력, 에러를 /dev/null 로 리디렉트 처리)
+	if( daemon(1, 0) == -1) 
+	{
+		fprintf(stderr, "[ERR] Process daemonize failed.[%s]\n\n", strerror(errno) );
+
+		ReadyToExit();
+		return EXIT_FAILURE;
+	}
+
+	// Signal 처리기 설정
+	SetSignalMain();
+
+		
+	// Process 기동 관련 정보 로깅 
+	std::vector<std::string> vecTemp;
+	std::vector< std::string >::const_iterator it;	
+	_LOG( LINF, "***********************************************************");
+	_LOG( LINF, " %s Start. Version: %s", PROG_NAME, PROG_VERSION);
+	_LOG( LINF, "***********************************************************");
+	_LOG( LINF, "Config                  : %s", strConfigFileName.c_str());
+	_LOG( LINF, "Log                     : %s/%s", CServiceConfig::GetInstance()->GetLogPath(), PROG_NAME);
+	_LOG( LINF, "Log level               : %d", CServiceConfig::GetInstance()->GetLogLevel());
+	_LOG( LINF, "RC ID                   : %s", CServiceConfig::GetInstance()->GetRcId());
+	_LOG( LINF, "RCDB                    : %s %u %s %s", CServiceConfig::GetInstance()->GetRcdbIp()
+                                                      , CServiceConfig::GetInstance()->GetRcdbPort()
+													  , CServiceConfig::GetInstance()->GetRcdbName()
+													  , CServiceConfig::GetInstance()->GetRcdbAcct());
+	_LOG( LINF, "FHS deamon tcp port     : %u", CServiceConfig::GetInstance()->GetFhsTransferDaemonPort());
+	_LOG( LINF, "Hash check level        : %u", CServiceConfig::GetInstance()->GetHashCheckLevel());
+	_LOG( LINF, "Max queue size          : %u", CServiceConfig::GetInstance()->GetMaxQueueSize() );
+	_LOG( LINF, "Replication");
+	_LOG( LINF, "  max thread            : %u", CServiceConfig::GetInstance()->GetMaxReplicationThread() );
+	_LOG( LINF, "  max retry             : %u", CServiceConfig::GetInstance()->GetMaxRetryCount());
+	_LOG( LINF, "  select delay (sec)    : %u", CServiceConfig::GetInstance()->GetTargetSelectInterval());
+	_LOG( LINF, "  select on start (hour): %u", CServiceConfig::GetInstance()->GetTargetSelectIntervalOnStarting());
+	_LOG( LINF, "  skip keyword" );
+	vecTemp = CServiceConfig::GetInstance()->GetSkipWord();
+	for( it = vecTemp.begin(); it != vecTemp.end(); it++ )
+	{
+		_LOG( LINF, "            : %s", it->c_str());
+	}
+	_LOG( LINF, "Hot Content");
+	_LOG( LINF, "  tcp listen  port      : %u", CServiceConfig::GetInstance()->GetFhsHotContentListenPort() );
+	_LOG( LINF, "  minimum fd count      : %u", CServiceConfig::GetInstance()->GetHotContentCreateMinimumFd() );
+	_LOG( LINF, "  max thread            : %u", CServiceConfig::GetInstance()->GetMaxCacheThread());
+	_LOG( LINF, "  expire time(sec)      : %u", CServiceConfig::GetInstance()->GetCacheFileTimeout());	
+
+	_LOG( LINF, "***********************************************************");
+
+	// Log Level 재설정. -> conf 설정대로 변경 처리.
+#ifdef _DEBUG_
+	CLogger::GetInstance()->SetLogLevel(LDBG);
+#else
+	CLogger::GetInstance()->SetLogLevel(CServiceConfig::GetInstance()->GetLogLevel());
+#endif
+	
+	// NEW 2014-07-02 huibong
+	// fimngd 와의 통신을 UDP -> TCP 변경함에 따라
+	// Main Process 에서 이와 관련된 Socket 을 생성토록 기능 추가
+	if( MakeHotContentListenSocket( g_listenHotContentSocket ) == false )
+	{
+		LOG( LERR, "Hot content listen socket create failed. => process exit." );
+		return EXIT_FAILURE;
+	}
+	
+	// Worker Process 생성
+	if(	MakeProcessWorker( g_listenHotContentSocket ) == false )
+	{
+		LOG( LERR, "Worker process make failed. => process exit.");
+
+		ReadyToExit();
+		return EXIT_FAILURE;
+	}
+	
+	// Process Rename
+	set_ps_display(PROG_NAME": Main [monitor worker process]", false);
+	
+	// Main Process : 그냥 대기
+	while( 1 )
+	{
+		// Main Process 는 할 일이 없다. 
+		// => Worker 프로세스 종료시 SIGCHLD 신호로 인해 신호처리기에서 Worker Process 재성성 수행함.
+		// => 따라서 그냥 시그널 대기
+		pause();
+	}
+
+	// 다음의 코드는 Daemon 으로 동작하기 때문에 수행되지 않는다.	
+	ReadyToExit();
+	return EXIT_SUCCESS;
+}
+
+
+// Hot Content 정보 수신을 위한 TCP Listen socket 을 생성한다.
+bool MakeHotContentListenSocket( int & listenSocket )
+{
+	listenSocket = socket( AF_INET, SOCK_STREAM, 0 );
+	if( listenSocket == -1 )
+	{
+		int errorNum = errno;
+		LOG( LERR, "Hot content listen socket create failed.[%d][%s]", errorNum, strerror( errorNum ) );		
+		return false;
+	}
+
+	struct sockaddr_in listenSockAddr;
+	socklen_t listenSockLen = 0;
+	memset( &listenSockAddr, 0x00, sizeof( listenSockAddr ) );
+
+	listenSockAddr.sin_family      = AF_INET;
+	listenSockAddr.sin_port        = htons( CServiceConfig::GetInstance()->GetFhsHotContentListenPort() );
+	listenSockAddr.sin_addr.s_addr = htonl( INADDR_ANY );
+
+	listenSockLen = sizeof( listenSockAddr );
+
+	int result = 0;
+
+	// Socket Port Reuse Option Set
+	int opt = 1;
+	result = setsockopt( listenSocket, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof( opt ) );
+	if( result != 0 )
+	{
+		int errorNum = errno;
+		LOG( LERR, "Hot content listen socket option[SO_REUSEADDR] set failed. [%d][%s]", errorNum, strerror( errorNum ) );		
+		return false;
+	}
+
+	// Keep Alive Option set
+	opt = 1;
+	result = setsockopt( listenSocket, SOL_SOCKET, SO_KEEPALIVE, &opt, sizeof( opt ) );
+	if( result != 0 )
+	{
+		int errorNum = errno;
+		LOG( LERR, "Hot content listen socket option[SO_KEEPALIVE] set failed. [%d][%s]", errorNum, strerror( errorNum ) );
+		return false;
+	}
+		
+	// Socket Bind
+	result = bind( listenSocket, ( struct sockaddr * )&listenSockAddr, listenSockLen );
+	if( result != 0 )
+	{
+		int errorNum = errno;
+		LOG( LERR, "Hot content listen socket bind failed.[%d][%s]", errorNum, strerror( errorNum ) );		
+		return false;
+	}
+
+	// Socket Listen
+	result = listen( listenSocket, DEFAULT_ACCEPT_WAIT_COUNT );
+	if( result != 0 )
+	{
+		int errorNum = errno;
+		LOG( LERR, "Hot content listen socket listen failed.[%d][%s]", errorNum, strerror( errorNum ) );		
+		return false;
+	}
+
+	return true;
+}
+
+
+/// @brief Worker Process 생성(fork) 처리 함수
+/// @return 생성 성공시 true, 실패시에는 false 를 반환.
+bool MakeProcessWorker( int listenHotContentSocket )
+{
+	// Worker 프로세스 fork
+	pid_t processId = fork();
+	if( processId < 0 ) // fork fail
+	{
+		int errorNum = errno;
+		LOG( LERR, "Worker process create failed. [%d][%s]", errorNum, strerror(errorNum) );
+		return false;
+	}
+	else if( processId == 0 ) // Child Process => Worker Process
+	{
+		// Worker Process Main 함수 호출 및 종료처리.
+		int iResult;
+		iResult = WorkerMain( listenHotContentSocket );
+
+		ReadyToExit();
+
+		// WorkerMain() 함수 return 값으로 종료처리되도록 한다.
+		exit( iResult );
+	}
+	else
+	{
+		// Parent Process => Logging
+		_LOG(LINF, "Worker[%d] create success." , processId);
+		
+		// 잠시 대기
+
+		// CHG 2015-09-14 huibong
+		// - #24369 usleep -> nanosleep 으로 변경 처리.
+		struct timespec sleep;
+		sleep.tv_sec = 0;
+		sleep.tv_nsec = 200000000;  // 0.2 sec
+		nanosleep( &sleep, NULL );
+
+	}
+	
+	return true;
+}
+
+/// @brief std 상에 trim 함수가 없어서 직접 구현 아니면 boost/algorithm/string.hpp 상의 boost::trim 함수 사용
+/// @return void
+void Trim( std::string & str)
+{
+	if( str.length() == 0 )
+		return;
+
+	// 문자열 뒤의 공백, TAB, CR 등의 문자 제거처리.
+	std::string::size_type pos = str.find_last_not_of(" \a\b\f\n\r\t\v");
+	if( pos != std::string::npos )
+		str.erase(pos + 1);
+
+	// 문자열 앞의 공백, TAB, CR 등의 문자 제거처리.
+	pos = str.find_first_not_of(" \a\b\f\n\r\t\v");
+	if( pos != std::string::npos )
+		str.erase(0, pos);
+}
+
+/// @brief 현재 Process가 기동중인지 여부를 판단하기 위한 함수( 프로세스 중복 실행 체크)
+/// @return 이미 해당 프로세스가 기동 중인 경우 true 반환, 그렇지 않으면 false 반환.
+bool IsCurrentProcessRun()
+{
+	char tempBuffer[512];
+	FILE * fd = NULL;
+	bool bRun = false;
+
+	snprintf( tempBuffer, sizeof(tempBuffer), "pgrep -x %s | sort", PROG_NAME );
+
+	fd = popen( tempBuffer, "r" );
+	if( fd == NULL )
+	{
+		// 오류 발생시 true 반환하여 프로세스 실행 방지처리
+		fprintf(stderr, "[ERR] Process duplication check failed.[popen error][%s]\n", strerror(errno));
+		return true;
+	}
+	else
+	{
+		memset( tempBuffer, 0x00, sizeof(tempBuffer) );
+		while( fgets( tempBuffer, sizeof(tempBuffer)-1, fd) != NULL )
+		{
+			string tempPid( tempBuffer );
+			Trim(tempPid);
+
+			if( atoi( tempPid.c_str() ) != getpid() )
+			{
+				fprintf(stderr, "[info] Process duplication found. pid[%d]\n", atoi(tempPid.c_str()));
+				bRun = true;
+				break;
+			}
+		}
+		
+		pclose( fd );
+		return bRun;
+	}
+}
+
+
+// 프로세스 종료 전 처리할 종료 관련 각 작업을 일괄로 처리하기 위한 함수.
+void ReadyToExit()
+{
+	if( g_listenHotContentSocket != -1 )
+	{
+		close( g_listenHotContentSocket );
+		g_listenHotContentSocket = -1;
+	}
+
+	// Logger 객체 종료 처리.
+	CLogger::Exit();
+
+	return;
+}
+
+/// @brief Main Process 가 종료 Signal 을 전달받은 경우 이를 처리하기 위한 함수.
+/// @param nSignalNumber [in] 발생한 시그널 Number
+/// @return void
+static void SignalMainTerminate(int nSignalNumber)
+{
+	// Signal Number 에 따른 로깅처리.
+	if( nSignalNumber == SIGTERM )
+	{
+		_LOG( LINF, "Main[%d] process exit by user signal[SIGTERM]. Good Bye..", getpid() );
+	}
+	else
+	{
+		_LOG( LWAR, "Main[%d] process exit by abnormal signal[%d]. Good Bye..", getpid(), nSignalNumber );
+	}
+	
+	ReadyToExit();
+
+	// CHG 2015-09-14 huibong
+	// - #24369 usleep -> nanosleep 으로 변경 처리.
+	struct timespec sleep;
+	sleep.tv_sec = 0;
+	sleep.tv_nsec = 500000000;  // 0.5 sec
+	nanosleep( &sleep, NULL );
+		
+	exit( EXIT_SUCCESS );
+}
+
+/// @brief Main Process 에서 자식 프로세스인 Worker Process 가 종료된 경우 시그널 처리를 위한 함수
+/// @param nSignalNumber [in] 발생한 시그널 Number
+/// @return void
+static void SignalWorkerDead(int nSignalNumber)
+{
+	pid_t deadPid;
+	int nDeadStatus;
+	
+	while( (deadPid = waitpid(-1, &nDeadStatus, WNOHANG)) > 0 )
+	{
+		// Worker 프로세스가 Signal 에 의해 종료되었는가?
+		if( WIFSIGNALED( nDeadStatus ) )
+		{
+			_LOG( LWAR, "Worker[%d] killed by signal[%d].", deadPid, WTERMSIG(nDeadStatus));
+		}
+		else
+		{
+			_LOG( LWAR, "Worker[%d] killed. Not signal.", deadPid);
+			
+			// Worker 프로세스가 EXIT_FAILURE 반환 ( 초기화 실패시 )
+			// 해당 내역을 화면 및 로그 상에 출력하고 
+			// Worker 프로세스를 재생성 처리하지 않는다.
+			if( WIFEXITED( nDeadStatus ) )
+			{
+				if( WEXITSTATUS( nDeadStatus ) == EXIT_FAILURE )
+				{
+					_LOG( LERR, "Worker[%d] initilaize failed.", deadPid);
+					_LOG( LERR, "Main[%d] abnormally exit by worker initialize failed. Good Bye..", getpid());
+					
+					ReadyToExit();
+
+					// CHG 2015-09-14 huibong
+					// - #24369 usleep -> nanosleep 으로 변경 처리.
+					struct timespec sleep;
+					sleep.tv_sec = 0;
+					sleep.tv_nsec = 500000000;  // 0.5 sec
+					nanosleep( &sleep, NULL );
+										
+					exit( EXIT_SUCCESS );
+				}
+			}			
+		}
+
+		// Worker Process 재생성 처리.
+		if( MakeProcessWorker( g_listenHotContentSocket ) == false )
+		{
+			// Worker Process 재성성 실패시
+			// 로깅 처리 후 Main 프로세스 종료 시그널 발생			
+			_LOG( LERR, "Worker process recreate failed. => Main process exit.");
+			raise( SIGTERM );
+		}
+		else
+		{
+			_LOG( LWAR, "Worker process recreate success.");
+		}
+	}
+
+	// 오류 발생시 해당 내역 로깅
+	if( deadPid < 0 )
+	{
+		int errorNum = errno;
+		LOG( LERR, "Main process error: SIG_CHLD receive but waitpid return error[%d][%s]", errorNum, strerror(errorNum));
+	}
+
+	return;
+}
+
+/// @brief Main 프로세스 signal 처리 설정을 위한 함수	
+/// @return void	
+void SetSignalMain()
+{
+	sigset_t set;
+	struct sigaction act;
+	memset(&act, 0x00, sizeof(act));
+
+	sigfillset( &set );
+	sigprocmask( SIG_SETMASK, &set, NULL );	
+	sigfillset( &act.sa_mask );
+	
+	// 무시 처리 signal
+	act.sa_handler = SIG_IGN;
+	sigaction( SIGPIPE, &act, NULL);	/* desciptor 오류 발생시 Process가 죽는 것은 방지하기 위하여 설정 */
+	sigaction( SIGHUP,  &act, NULL);	/* process를 기동시킨 관리자의 로그아웃시, 또는 config reload 등의 처리 signal*/
+	sigaction( SIGINT,  &act, NULL);	/* ^C 키를 누른 경우 받는 신호 => demon 으로 기동되기 땜시 이 신호 못받음 */
+	sigaction( SIGQUIT, &act, NULL);	/* 키보드에 의한  Abort 신호 처리 => ? */
+	
+	// Child Process 인 Worker 프로세스 종료에 대한 처리기 설정.
+	act.sa_handler = SignalWorkerDead;
+	sigaction( SIGCHLD, &act, NULL);
+	
+	// 사용자 종료 또는 에러 관련 신호 처리.
+	act.sa_handler = SignalMainTerminate;
+	sigaction( SIGTERM, &act, NULL);	/* kill -TERM 에 의한 프로세스 종료시 */
+
+	sigemptyset(&set);					/* 신호 처리기 처리 설정 위한 블록 해제 */
+	sigprocmask(SIG_SETMASK, &set, NULL);
+}

rcts/rc_rmcd/src/Main.h

@@ -0,0 +1,64 @@
+/***************************************************************************
+                    rc_rmcd Main Header ( Main.h )
+                -----------------------------------------
+	begin      : 2010/03/09
+	copyright  : (C) 2005 Solbox Inc.
+	author     : Storage Dev Team
+	email      : storage.sd@solbox.com
+	version    : 3.3
+
+	CopyRight(C) 2005 Solbox Inc. All Rights reserved.
+	Redistribution and use in source and binary forms, with or with out
+	modification, are not permitted in outside of Solbox Inc.
+***************************************************************************/
+
+#ifndef __RC_RMCD_MAIN_H__
+#define __RC_RMCD_MAIN_H__
+
+#include <string>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+	// 사용 방법을 화면에 표시하기 위한 함수.
+	void PrintUsage(void);
+
+	// Version 정보를 화면에 표시하기 위한 함수
+	void PrintVersion(void);
+	
+	// Hot Content 정보 수신을 위한 TCP Listen socket 을 생성한다.
+	bool MakeHotContentListenSocket( int & listenSocket );
+
+	/// @brief Worker Process 생성(fork) 처리 함수
+	/// @return 생성 성공시 true, 실패시에는 false 를 반환.
+	bool MakeProcessWorker( int listenHotContentSocket );
+	
+	// std 상에 trim 함수가 없어서 직접 구현 아니면 boost/algorithm/string.hpp 상의 boost::trim 함수 사용
+	// @param str [in/out] Trim 할 문자열을 저장한 String 참조변수.
+	// @return void
+	void Trim( std::string & str );
+
+	/// @brief 현재 Process가 기동중인지 여부를 판단하기 위한 함수( 프로세스 중복 실행 체크)
+	/// @return 이미 해당 프로세스가 기동 중인 경우 true 반환, 그렇지 않으면 false 반환.
+	bool IsCurrentProcessRun( void );
+
+	// 프로세스 종료에 따른 반복적인 종료 관련 작업을 수행하기 위한 함수.
+	void ReadyToExit(void);
+	
+	/// @brief Main 프로세스 signal 처리 설정을 위한 함수	
+	/// @return void	
+	void SetSignalMain( void );
+
+	/* Signal 처리를 위한 각 Signal Handler 함수는 
+	 * 다른 Code 에서 Include 처리시 Static 관련 문제로 인해 
+	 * 본 Header 에서 선언처리 하지 않음. cpp 에만 존재 
+	 */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __RC_RMCD_MAIN_H__ */
+

rcts/rc_rmcd/src/Makefile

@@ -0,0 +1,83 @@
+#****************************************************************************
+#                Makefile for rc_rmcd
+#                -----------------------------------------
+#
+#    begin      : 2013/05/19
+#    copyright  : (C) 2005 Solbox Inc.
+#    author     : Dev Storage Team
+#    email      : huibong@solbox.com
+#    version    : 3.5.0
+#
+#    CopyRight(C) 2005 Solbox Inc. All Rights reserved.
+#    Redistribution and use in source and binary forms, with or with out
+#    modification, are not permitted in outside of Solbox Inc.
+#*****************************************************************************
+
+
+# Program info
+PROG_NAME = rc_rmcd
+REVISION = 1428
+PROG_VERSION = 3.5.0.$(REVISION)-`date +%Y%m%d%H%M%S`
+
+
+DEFAULT_CONFIG_FILE = /user/service/etc/rcts.conf
+
+
+INSTALL_BIN = /user/service/bin
+INSTALL_CONF = /user/service/etc
+
+
+# Compiler info
+CC     = /usr/bin/g++
+
+CFLAGS = -Wall -O3 -g -Wreturn-type -Wunused -Wuninitialized\
+		 -Wparentheses -Wshadow -Wpointer-arith -Woverloaded-virtual\
+		 -fno-rtti -D_REENTRANT
+
+LFLAGS = 
+
+DFLAGS = -DPROG_NAME=\"$(PROG_NAME)\" -DPROG_VERSION=\"$(PROG_VERSION)\" -DDEFAULT_CONFIG_FILE=\"$(DEFAULT_CONFIG_FILE)\"
+
+
+# Application Enviroment
+APP = $(PROG_NAME) 
+
+DIR_INCLUDE = -I./. -I../lib -I /user/db/pgsql/include -I../
+DIR_LIB     = -L../lib
+
+OBJ = ServiceConfig.o RcdbInfo.o Util.o Database.o \
+	  CacheRequestData.o CacheData.o CacheJobList.o \
+	  ProcessStatus.o ProperFhs.o \
+	  ReplicateInsert.o ReplicateSelect.o  ReplicateQueueControl.o \
+	  FtsdSocketControl.o ReplicateThread.o ReplicateControl.o \
+	  FimngdSocketControl.o CacheDelete.o CacheInsert.o CacheOrder.o \
+	  CacheThread.o CacheControl.o\
+	  Worker.o Main.o
+	  
+LIBS = ../lib/libInterCommon.a -lpthread -lcrypt /user/db/pgsql/lib/libpq.a
+
+
+############################
+
+all:$(APP)
+	sync
+
+%.o: %.cpp
+	$(CC) $(CFLAGS)  -o $@ -c $^ $(DFLAGS) $(DIR_INCLUDE)
+
+
+$(PROG_NAME): $(OBJ)
+	$(CC) $(LFLAGS) -o $@ $^ $(DFLAGS) $(DIR_LIB) $(LIBS)
+
+
+clean:
+	-rm -f *.o core.$(PROG_NAME) *.out *.log
+	-rm -f $(APP)
+	sync
+
+
+install : $(APP)
+	-cp $(APP) $(INSTALL_BIN)/$(APP)
+	sync
+
+# End of Makefile

rcts/rc_rmcd/src/ProcessStatus.cpp

@@ -0,0 +1,297 @@
+#include "ProcessStatus.h"
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "Logger.h"
+#include "ProcessRename.h"
+
+// NEW 2014-06-19 huibong
+// 설정 가능한 동시 Thread 수를 제한.
+#define MAX_THREAD_COUNT_LIMIT 1024
+
+// Process 정보 update 주기  (sec)
+#define PROCESS_STATUS_UPDATE_TIME  2
+
+
+////////////////////////////////////////
+
+// 생성자
+CProcessStatus::CProcessStatus( CDataQueue<CSourceData>* const pQueueSource
+	, CDataQueue<CRetryData>* const pQueueRetry
+	, CDataQueue<CCompleteData>* const pQueueCompleteReplication
+	, CDataQueue<CCacheRequestData>* const pQueueCacheRequest
+	, CDataQueue<CCacheData>* const pQueueCacheComplete
+	, CCacheJobList* const pCacheJob )
+	: m_pQueueSource( pQueueSource ) 
+	, m_pQueueRetry( pQueueRetry ) 
+	, m_pQueueCompleteReplication( pQueueCompleteReplication )
+	, m_pQueueCacheRequest( pQueueCacheRequest )
+	, m_pQueueCacheComplete( pQueueCacheComplete )
+	, m_pCacheJob( pCacheJob )
+{
+	m_threadHandle = 0;
+
+	m_nMaxReplicationThreadCount = 0;
+	m_nMaxCacheThreadCount       = 0;
+
+	m_nCurrentReplicationCount = 0;
+    m_nCurrentCacheCount       = 0;
+	
+	// Lock 초기화
+	pthread_mutex_init(&m_mxReplicateThreadCount, NULL);
+	pthread_mutex_init(&m_mxCacheThreadCount, NULL);
+}
+
+// 소멸자
+CProcessStatus::~CProcessStatus()
+{
+	// Thread 동작 정지 처리
+	// - 만약 Thread 가 이미 종료된 경우 m_threadHandle 이 다른 Thread Handle 일 수 있으므로 
+	//   업무 Flow 수정시 주의할 것
+	if( m_threadHandle != 0 )
+		pthread_cancel( m_threadHandle );
+
+	pthread_mutex_destroy(&m_mxReplicateThreadCount);
+	pthread_mutex_destroy(&m_mxCacheThreadCount);	
+}
+
+// 객체 초기화
+// @param [in] nMaxReplicationThreadCount Replication 처리 관련 동시 최대 생성 가능 Thread  수
+// @param [in] nMaxCacheThreadCount Hot Content cache 처리 관련 동시 최대 생성 가능 Thread  수
+// @return true 성공
+//         false 생성자로 전달된 객체 포인터가 유효하지 않은 경우, 
+//               인자로 전달된 최대 Thread 수가 너무 큰 경우.(MAX_THREAD_COUNT_LIMIT 초과시)
+bool CProcessStatus::Init(const unsigned int nMaxReplicationThreadCount, const unsigned int nMaxCacheThreadCount)
+{
+	// 생성자로 전달된 변수 Check.
+	if( m_pQueueSource == NULL || m_pQueueRetry == NULL || m_pQueueCompleteReplication == NULL
+		|| m_pQueueCacheRequest == NULL || m_pQueueCacheComplete == NULL || m_pCacheJob == NULL )
+	{
+		LOG( LERR, "module constructor parameter include null. check parameter" );
+		return false;
+	}
+
+	// 전달받은 동시 생성가능 Thread 가 내부 정의된 제약값을 초과하는지 확인
+	if( nMaxReplicationThreadCount > MAX_THREAD_COUNT_LIMIT )
+	{
+		LOG( LERR, "replication max thread count[%u] is too high. set below limit[%d]"
+			, nMaxReplicationThreadCount, MAX_THREAD_COUNT_LIMIT );
+		return false;
+	}
+	if( nMaxCacheThreadCount > MAX_THREAD_COUNT_LIMIT )
+	{
+		LOG( LERR, "hot content cache max thread count[%u] is too high. set below limit[%d]"
+			, nMaxCacheThreadCount, MAX_THREAD_COUNT_LIMIT );
+		return false;
+	}
+
+	m_nMaxReplicationThreadCount = nMaxReplicationThreadCount;
+	m_nMaxCacheThreadCount       = nMaxCacheThreadCount;
+
+	// CHG 2014-06-18 huibong
+	// - 본 함수는 Worker 상에서 각 객체 모듈 초기화 중에 호출되므로...
+	//   프로세스 표시명을 아직 변경해서는 안된다.
+    //UpdateTitle();
+	
+	return true;
+}
+
+// thread를 생성하여 관련 작업을 수행.
+bool CProcessStatus::Start()
+{
+	int nRet = ::pthread_create( &m_threadHandle, NULL, CProcessStatus::threadFunc, this );
+	if( nRet != 0 )
+	{
+		// Thread 생성 실패시
+		int errorNum = errno;
+		LOG( LERR, "Thread create failed.[%d][%s]", errorNum, strerror( errorNum ) );
+
+		return false;
+	}
+
+	return true;
+}
+
+void* CProcessStatus::threadFunc( void* arg )
+{
+	CProcessStatus* pObject = reinterpret_cast<CProcessStatus *>( arg );
+	pthread_detach( pthread_self() );
+
+	while( 1 )
+	{
+		pthread_testcancel();		
+		pObject->UpdateTitle();		
+		pthread_testcancel();
+				
+		sleep( PROCESS_STATUS_UPDATE_TIME );
+			
+	}
+
+	// NEW 2014 - 06 - 23 huibong
+	// Thread 종료시 m_threadHandle 값을 초기화 처리.
+	// - 소멸자에서 잘못된 Thread 를 종료할 수 있기 때문.
+	pObject->m_threadHandle = 0;
+
+	return NULL;
+}
+
+
+// 현재 프로세스 표시 정보 업데이트 
+void CProcessStatus::UpdateTitle(void)
+{
+	// Rs: replication source queue size
+	// Rt: current replication thread count
+	// Rr: replication retry queue size
+	// Rc: replication complete queue size
+
+	// Cr: FHS 로 부터 수신된 Hot Content Cache 요청 정보 저장 queue size
+	// Cj: hot content cache job list size
+	// Ct: current hot content cache thread count
+	// Cc: hot content cache complete queue size
+		
+#if defined(__FreeBSD__)
+	setproctitle("[Rs%u Rt%d Rr%u Rc%u  Cr%u Ct%d Cj%u Cc%u]",
+			m_pQueueSource->GetSize(), 
+			m_nCurrentReplicationCount,
+			m_pQueueRetry->GetSize(),
+			m_pQueueCompleteReplication->GetSize(),
+			m_pQueueContentInfo->GetSize(),
+			m_nCurrentCacheCount,
+			m_pListJob->GetSize(),
+			m_pQueueCompleteCache->GetSize() );
+
+#else
+	char szTemp[100] = {0};	
+	sprintf(szTemp,	 "%s: [Rs%u Rt%d Rr%u Rc%u  Cr%u Cj%d Ct%d Cc%u]",
+			PROG_NAME,
+			m_pQueueSource->GetSize(),
+		    m_nCurrentReplicationCount,
+			m_pQueueRetry->GetSize(),
+			m_pQueueCompleteReplication->GetSize(),
+			m_pQueueCacheRequest->GetSize(),
+			m_pCacheJob->GetSize(),
+			m_nCurrentCacheCount,			
+			m_pQueueCacheComplete->GetSize() );
+	
+	set_ps_display(szTemp, false);
+
+#endif
+
+	return ;
+}
+
+// Replication 관련 동시 생성 가능한 Thread 수를 반환
+unsigned int CProcessStatus::GetValidReplicationCount(void)
+{	
+	// 생성 불가인 경우.
+	if( m_nMaxReplicationThreadCount == 0 )
+		return 0;
+	else
+	{
+		int nAvailCount;
+
+		// lock 설정 후 사용 가능 Thread 수 계산.
+		pthread_mutex_lock( &m_mxReplicateThreadCount );
+		nAvailCount = m_nMaxReplicationThreadCount - m_nCurrentReplicationCount;
+		pthread_mutex_unlock( &m_mxReplicateThreadCount );
+
+		// 현재 생성된 Thread 수가 Max 값보다 큰 경우
+		// 사용 가능 Thread 수를 0 으로 전달.
+		if( nAvailCount < 0 )
+			return 0;		
+		else
+			return nAvailCount;
+	}
+}
+
+// Hot Content Cache 관련 동시 생성 가능한 Thread 수를 반환
+unsigned int CProcessStatus::GetValidCacheCount(void)
+{
+	// 생성 불가인 경우.
+	if( m_nMaxCacheThreadCount <= 0 )
+		return 0;
+	else
+	{
+		int nAvailCount;
+
+		// lock 설정 후 사용 가능 Thread 수 계산.
+		pthread_mutex_lock( &m_mxCacheThreadCount );
+		nAvailCount = m_nMaxCacheThreadCount - m_nCurrentCacheCount;
+		pthread_mutex_unlock( &m_mxCacheThreadCount );
+
+		// 현재 생성된 Thread 수가 Max 값보다 큰 경우
+		// 사용 가능 Thread 수를 0 으로 전달.
+		if( nAvailCount < 0 )
+			return 0;
+		else
+			return nAvailCount;
+	}
+}
+
+// Replication 관련 작업 Thread 수를 1 증가 처리
+void CProcessStatus::AddReplicationCount(void)
+{
+	AddCount(Replication);
+}
+
+// Replication 관련 작업 Thread 수를 1 감소 처리
+void CProcessStatus::SubtractReplicationCount(void)
+{
+	SubtractCount(Replication);
+}
+
+// Hot content cache 관련 작업 Thread 수를 1 증가 처리
+void CProcessStatus::AddCacheCount(void)
+{
+	AddCount(Cache);
+}
+
+// Hot content cache 관련 작업 Thread 수를 1 감소 처리
+void CProcessStatus::SubtractCacheCount(void)
+{
+	SubtractCount(Cache);
+}
+
+// 전달받은 작업의 Thread 수를 1 증가 시킨다.
+void CProcessStatus::AddCount(Job job)
+{
+	if( job == Cache )
+	{
+		pthread_mutex_lock(&m_mxCacheThreadCount);	
+		++m_nCurrentCacheCount;
+		pthread_mutex_unlock(&m_mxCacheThreadCount);		
+	}
+	else if( job == Replication )
+	{
+		pthread_mutex_lock(&m_mxReplicateThreadCount);		
+		++m_nCurrentReplicationCount;
+		pthread_mutex_unlock(&m_mxReplicateThreadCount);		
+	}
+	
+	// 프로세스 출력 표시명 갱신
+	// - Worker 프로세스에서 주기적으로 하므로.. 제거 처리.
+	//UpdateTitle();	
+}
+
+// 전달받은 작업의 Thread 수를 1 감소 시킨다.
+void CProcessStatus::SubtractCount(Job job)
+{
+	if( job == Cache )
+	{
+		pthread_mutex_lock(&m_mxCacheThreadCount);		
+		--m_nCurrentCacheCount;
+		pthread_mutex_unlock(&m_mxCacheThreadCount);		
+	}
+	else if( job == Replication )
+	{
+		pthread_mutex_lock(&m_mxReplicateThreadCount);
+		--m_nCurrentReplicationCount;
+		pthread_mutex_unlock(&m_mxReplicateThreadCount);
+	}
+
+	// 프로세스 출력 표시명 갱신
+	// - Worker 프로세스에서 주기적으로 하므로.. 제거 처리.
+	//UpdateTitle();	
+}

rcts/rc_rmcd/src/ProcessStatus.h

@@ -0,0 +1,156 @@
+/***************************************************************************
+                Process 상태 정보 저장 및 console 출력 처리 class
+                -----------------------------------------
+    begin      : 2010/03/05
+    copyright  : (C) 2005 Solbox Inc.
+    author     : storage dev team
+    email      : storage.sd@solbox.com
+    version    : 3.3
+
+    CopyRight(C) 2005 Solbox Inc. All Rights reserved.
+    Redistribution and use in source and binary forms, with or with out
+    modification, are not permitted in outside of Solbox Inc.
+***************************************************************************/
+
+#ifndef __PROCESS_STATUS_H__
+#define __PROCESS_STATUS_H__
+
+#include <pthread.h>
+
+#include "DataQueue.hpp"
+#include "ReplicationData.h"
+#include "CacheRequestData.h"
+#include "CacheJobList.h"
+
+// CProcessStatus class
+// - 프로세스 내부에서 사용 중인 Queue 정보와
+// - Replcation 처리 thread 수, Hot Content 처리 thread 수를 관리,
+// - 해당 정보를 console 상에 표시하는 역활을 수행한다.
+// - 2016-06-18 다른 모듈과 연동시 반환값 처리 관련 문제가 많아
+//              확장성 포기하고 업무 Flow 에 맞게 단순하게 동작하도록 수정 처리함.
+//              특히 무제한 설정 관련 기능은 전부 제거 처리함.
+class CProcessStatus
+{
+	private:
+
+		// Replication 처리 관련 동시 최대 생성 가능 Thread  수.
+		int m_nMaxReplicationThreadCount;
+
+		// Hot Content cache 처리 관련 동시 최대 생성 가능 Thread  수
+		int m_nMaxCacheThreadCount;
+
+		// Lock 처리 관련
+		pthread_mutex_t m_mxReplicateThreadCount;
+		pthread_mutex_t m_mxCacheThreadCount;
+
+
+		////// 프로세스 title 로 모니터 대상 정보 /////////////
+
+		// Replication 처리 관련 현재 생성된 Thread  수.
+		int m_nCurrentReplicationCount;
+
+		// Hot Content cache 처리 관련 현재 생성된 Thread  수
+		int m_nCurrentCacheCount;
+		
+		// Replication content 저장 queue 에 대한 포인터
+		// 생성자를 통해 전달받음.
+		CDataQueue<CSourceData>* m_pQueueSource;
+
+		// Replication 재시도 content 저장 queue 에 대한 포인터
+		// 생성자를 통해 전달받음.
+		CDataQueue<CRetryData>* m_pQueueRetry;
+
+		// Replication 완료 정보 저장 queue 에 대한 포인터
+		// 생성자를 통해 전달받음.
+		CDataQueue<CCompleteData>* m_pQueueCompleteReplication;
+
+		// Hot Content cache 요청 정보 저장 관련 queue 에 대한 포인터.
+		CDataQueue<CCacheRequestData>* m_pQueueCacheRequest;
+
+		// Hot Content cache 처리 완료 관련 queue 에 대한 포인터.
+		CDataQueue<CCacheData>* m_pQueueCacheComplete;
+
+		// Hot Content cache 생성 관리 job 객체에 대한 포인터.
+		CCacheJobList* m_pCacheJob;
+
+		//////////////////////////////////////////////////
+		
+		// 작업의 종류를 구분하는 열거형 변수
+		// Replication : 0, Cache : 1
+		enum Job { Replication, Cache };
+
+
+		// 쓰레드 핸들
+		pthread_t m_threadHandle;
+		
+		
+	public :
+		// 생성자
+		// @param [in] pQueueSource : Replication content 저장 queue 에 대한 포인터
+		// @param [in] pQueueRetry  : Replication 재시도 content 저장 queue 에 대한 포인터
+		// @param [in] pQueueCompleteReplication : Replication 완료 정보 저장 queue 에 대한 포인터
+		// @param [in] pQueueContentInfo : 캐시 요청 정보 저장 관련 queue 에 대한 포인터.
+		// @param [in] pQueueCompleteCache : 캐시 처리 완료된 queue 에 대한 포인터.
+		// @param [in] pListJob : 캐시 생성 job 객체에 대한 포인터.
+		CProcessStatus( CDataQueue<CSourceData>* const pQueueSource
+			, CDataQueue<CRetryData>*            const pQueueRetry
+			, CDataQueue<CCompleteData>*         const pQueueCompleteReplication
+			, CDataQueue<CCacheRequestData>*     const pQueueCacheRequest
+			, CDataQueue<CCacheData>*            const pQueueCacheComplete
+			, CCacheJobList*                     const pCacheJob
+			);
+
+		// 소멸자
+		~CProcessStatus();
+		
+		// 객체 초기화
+		// @param [in] nMaxReplicationThreadCount Replication 처리 관련 동시 최대 생성 가능 Thread  수
+		// @param [in] nMaxCacheThreadCount Hot Content cache 처리 관련 동시 최대 생성 가능 Thread  수
+		// @return true 성공
+		//         false 생성자로 전달된 객체 포인터가 유효하지 않은 경우, 
+		//               인자로 전달된 최대 Thread 수가 너무 큰 경우.(MAX_THREAD_COUNT_LIMIT 초과시)
+		bool Init(const unsigned int nMaxReplicationThreadCount, const unsigned int nMaxCacheThreadCount);
+		
+		// thread를 생성하여 프로세스 출력 상태 갱신 작업을 수행.
+		bool Start();
+
+
+		// 현재 프로세스 표시 정보 업데이트 
+		void UpdateTitle( void );
+		
+		// Replication 관련 동시 생성 가능한 Thread 수를 반환		
+		unsigned int GetValidReplicationCount( void );
+
+		// Hot Content Cache 관련 동시 생성 가능한 Thread 수를 반환
+		unsigned int GetValidCacheCount( void );
+		
+
+		// Replication 관련 작업 Thread 수를 1 증가 처리
+		void AddReplicationCount(void);
+		
+		// Replication 관련 작업 Thread 수를 1 감소 처리
+		void SubtractReplicationCount(void);
+		
+
+		// Hot content cache 관련 작업 Thread 수를 1 증가 처리
+		void AddCacheCount(void);
+		
+		// Hot content cache 관련 작업 Thread 수를 1 감소 처리
+		void SubtractCacheCount(void);
+		
+
+	private :
+
+		// 스레드 함수
+		static void* threadFunc( void* arg );
+
+				
+		// 전달받은 작업의 Thread 수를 1 증가 시킨다.
+		void AddCount(CProcessStatus::Job job);
+
+		// 전달받은 작업의 Thread 수를 1 감소 시킨다.
+		void SubtractCount(CProcessStatus::Job job);
+				
+};
+
+#endif //__PROCESS_STATUS_H__

rcts/rc_rmcd/src/ProperFhs.cpp

@@ -0,0 +1,322 @@
+#include "ProperFhs.h"
+
+#include <errno.h>
+#include <string.h>
+#include <algorithm>
+
+#include "Logger.h"
+#include "Database.h"
+
+
+// 처리 loop 간의 sleep time 정의
+#define DEFAULT_SLEEP_TIME  30
+// RCDB 접속 실패 또는 Query 실패 등의 상황 발생시 
+#define MAX_SLEEP_TIME     180
+
+// Query 문장 저장을 위한 Buffer 크기
+#define DEFAULT_QUERY_BUFFER_SIZE 512
+
+
+// 생성자
+CProperFhs::CProperFhs()	
+{
+	// 멤버 변수 초기화
+	pthread_mutex_init( &m_mutexLock, NULL );
+	m_indexRoundRobin = 0;
+
+	m_threadHandle = 0;
+
+	m_uSleep = DEFAULT_SLEEP_TIME;
+}
+
+// 소멸자
+CProperFhs::~CProperFhs()
+{
+	pthread_mutex_destroy( &m_mutexLock );
+
+	if(m_threadHandle != 0 )
+		pthread_cancel( m_threadHandle );
+	    
+}
+
+// 객체 초기화
+bool CProperFhs::Init( )
+{
+	// RCDB 접속 정보 Load.
+	m_rcdbInfo.Load();
+
+	// RCDB 접속 처리를 위한 객체 생성
+	DataBase rcdb;
+
+	// RCDB 접속 시도 및 접속 실패시
+	if( rcdb.PgOpenDB( m_rcdbInfo.m_strRcdbIp, m_rcdbInfo.m_nRcdbPort
+		, m_rcdbInfo.m_strRcdbName, m_rcdbInfo.m_strRcdbAcct
+		, m_rcdbInfo.m_strRcdbAcctPw ) == NULL )
+	{
+		LOG( LERR, "RCDB connection failed." );
+		return false;
+	}
+	else
+	{
+		// 접속 성공한 경우...
+		LOG( LINF, "RCDB connection test ok..." );
+
+		rcdb.PgCloseDB();
+
+		return true;		
+	}
+}
+
+// thread를 생성하여 업무 flow 를 시작.
+bool CProperFhs::Start()
+{
+	int nRet = ::pthread_create( &m_threadHandle, NULL, CProperFhs::threadFunc, this );
+	if( nRet )
+	{
+		// Thread 생성 실패시
+		int errorNum = errno;
+		LOG( LERR, "Thread create failed.[%d][%s]", errorNum, strerror( errorNum ) );
+
+		return false;
+	}
+
+	return true;
+}
+
+// 스레드 함수
+void* CProperFhs::threadFunc( void* arg )
+{
+	CProperFhs* pObject = reinterpret_cast<CProperFhs *>( arg );
+	pthread_detach( pthread_self() );
+
+	while( 1 )
+	{
+		pthread_testcancel();
+		pObject->Execute();
+		pthread_testcancel();
+
+		// 1회 수행 후 지정된 시간 만큼 대기
+		sleep( pObject->m_uSleep );
+	}
+
+	// NEW 2014-06-19 huibong
+	// Thread 종료시 m_threadHandle 값을 초기화 처리.
+	// - 소멸자에서 잘못된 Thread 를 종료할 수 있기 때문.
+	pObject->m_threadHandle = 0;
+
+	return NULL;
+}
+
+// 스레드 내에서 각 loop 단위 처리 호출 함수.
+bool CProperFhs::Execute()
+{
+	if( UpdateFromDB() == false )
+	{
+		// RCDB 연결 또는 query 관련 문제 발생시...
+		// sleep time 을 높인다.
+		m_uSleep = MAX_SLEEP_TIME;
+	}
+	else
+	{
+		m_uSleep = DEFAULT_SLEEP_TIME;
+	}
+
+	return true;
+}
+
+
+// Proper fhs의 목록을 RCDB t_fhs_top_status 에서 조회.
+// CHG 2014-06-24 huibong
+// #19042 의 팀회의 결과에 따라
+// - RCDB 연결 실패 및 Query 오류 발생시 이전 FHS 목록 유지
+// - RCDB 에서 조회된 Proper FHS 가 없는 경우.. Proper FHS 목록 Clear 처리
+// - 그외 정상 처리.
+bool CProperFhs::UpdateFromDB()
+{
+	// 1. RCDB 와 연결처리.
+	DataBase rcdb;
+	if( rcdb.PgOpenDB( m_rcdbInfo.m_strRcdbIp, m_rcdbInfo.m_nRcdbPort
+		, m_rcdbInfo.m_strRcdbName, m_rcdbInfo.m_strRcdbAcct
+		, m_rcdbInfo.m_strRcdbAcctPw ) == NULL )
+	{
+		// RCDB 접속이 실패
+		// - 기존 proper fhs 항목 유지 처리
+		LOG( LERR, "RCDB connection failed." );
+		return false;
+	}
+
+	// 2. RCDB t_fhs_top_status 테이블 조회
+	char szQuery[DEFAULT_QUERY_BUFFER_SIZE];
+	// Query 수행 결과값 저장을 위한 변수..	
+	int nResult = 0;
+
+	// t_fhs_top_status 테이블에 업데이트 된 FHS 목록 중...
+	// 최근 1분내에 갱신된 정보만 사용한다.
+	// - 신형 rc_statd 에서는 29 sec 마다 갱신 처리
+	snprintf( szQuery, DEFAULT_QUERY_BUFFER_SIZE - 1,
+		"SELECT fhs_hostname FROM t_fhs_top_status "
+		" WHERE lastupdate >= (NOW() - interval'01 minute') " );
+
+	// Query 수행 및 결과 확인
+	rcdb.PgDoExec( szQuery );
+	nResult = rcdb.PgResult( DataBase::NOT_CLEAR );
+	if( nResult < 0 )
+	{
+		// Query 수행 실패시
+		// - RCDB 연결 오류 발생의 경우.
+		// - 기존 proper fhs 항목 유지 처리
+		LOG( LERR, "RCDB t_fhs_top_status select failed.[%s][%s]"
+			, rcdb.GetErrorMessage().c_str(), szQuery );
+
+		rcdb.PgClear();
+		rcdb.PgCloseDB();
+		return false;
+	}
+
+	// 결과 Row 수 확인 
+	nResult = rcdb.GetNoTuples();
+	if( nResult < 0 )
+	{
+		// 오류 발생시
+		// - 기존 proper fhs 항목 유지 처리
+		LOG( LERR, "RCDB t_fhs_top_status GetNoTuples() error[%s][%s]"
+			, rcdb.GetErrorMessage().c_str(), szQuery );
+
+		rcdb.PgClear();
+		rcdb.PgCloseDB();
+		
+		return false;
+	}
+	else if( nResult == 0 )
+	{
+		// 조회 결과가 존재하지 않는 경우
+		// - proper fhs 목록 초기화.
+		_LOG( LWAR, "CProperFhs: Proper fhs not exist. Check RCDB t_fhs_top_status table.");
+		
+		rcdb.PgClear();
+		rcdb.PgCloseDB();
+
+		pthread_mutex_lock( &m_mutexLock );
+		m_vecFHS.clear();
+		m_indexRoundRobin = 0;
+		pthread_mutex_unlock( &m_mutexLock );
+		
+		return true;
+	}
+
+	// 3. 조회 결과가 존재하는 경우.
+	//  - 내부 변수에 저장
+	pthread_mutex_lock( &m_mutexLock );
+	m_vecFHS.clear();
+	m_indexRoundRobin = 0;
+
+	std::string strTemp;
+	for( int i = 0; i < nResult; i++ )
+	{
+		strTemp = rcdb.GetValue( i, 0 );
+
+		if( strTemp.size() > 0 )
+		{
+			_LOG( LDBG, "CProperFhs: add host [%s]", strTemp.c_str() );
+			m_vecFHS.push_back( strTemp );
+		}
+	}
+	pthread_mutex_unlock( &m_mutexLock );
+	
+	// RCDB 관련 정리 처리.
+	rcdb.PgClear();
+	rcdb.PgCloseDB();
+
+	return true;
+}
+
+// 현재 저장된 FHS 의 수를 반환.
+int CProperFhs::GetFhsCount()
+{
+    return (int)m_vecFHS.size();
+}
+
+// 적절한 FHS들의 정보를 전달한다.
+// @param [in] nCount FHS정보의 요청 개수.
+// @param [out] vecRet 적절한 FHS의 host정보를 vector 타입으로 전달 한다.
+// @param [in] listIgnoreFhs 무시할 host정보를 입력한다.
+// @return 성공은 return true, 그렇지 않으면 false. 
+// @note return false를 해도 nCount만큼은 못보내지만 일부 리스트가 전달 될 수 있다.
+bool CProperFhs::GetProperFhs( unsigned int nCount, std::vector<std::string> &vecRet, std::list<std::string> &listIgnoreFhs )
+{
+	// CHG 2014-06-24 huibong
+	// FHS 목록 전달시 m_indexRoundRobin 변수 사용으로 인해 중복된 FHS 가 선택되어 전달될 수 있음.
+	// 따라서 이에 대한 수정 처리함.
+
+	// 결과값을 전달할 vector 참조 객체 초기화.	
+	// - 요청한 수만큼 FHS 가 존재하지 않을 경우 false 를 반환하므로...
+	// - 호출 모듈에서 문제가 생기지 않도록 미리 Clear 처리
+	vecRet.clear();
+		
+	// 요청한 FHS 수가 저장된 FHS 수보다 많은 경우..
+	// - 동일 FHS 장비에 Content 복제 또는 cache 가 동일하게 발생하여....
+	// - 동일 파일 Write 에 의한 content 이상 문제를 발생시킬수 있으므로.. 방어 처리.
+	if( nCount > m_vecFHS.size() )
+	{
+		LOG( LERR, "proper fhs count[%zu], but request count[%u]. check flow."
+			, m_vecFHS.size(), nCount );
+		return false;
+	}
+	
+	// 변수 생성.	
+	std::list<std::string>::iterator itIgnore;
+
+	// 중복된 FHS 정보가 push 되지 않기 위한 while loop 체크 횟수 저장 변수
+	unsigned int iCheckCount = 0;
+	
+	// Lock 처리
+	pthread_mutex_lock( &m_mutexLock );
+
+	// 내부 Proper FHS 목록 정보가 존재하지 않는 경우.
+	// - m_vecFHS 의 크기값이 Thread 모듈에 의해 변경될 수 있으므로...
+	// - Lock 처리 후 판단하는 것으로 위치 수정.
+	if( m_vecFHS.size() <= 0 )
+	{
+		// Lock 해제
+		pthread_mutex_unlock( &m_mutexLock );
+
+		LOG( LWAR, "Proper FHS not exist." );
+		return false;
+	}
+	
+	// 맴버변수인 index 지시자의 오버플로우를 막기 위해 계산 처리.
+	m_indexRoundRobin %= m_vecFHS.size();
+				
+	// 요청한 개수 만큼 저장할때까지 반복.
+	// - 중복 방지를 위해 루프 횟수는 최대 저장된 FHS 횟수 만큼으로 제한
+	while( vecRet.size() != nCount && iCheckCount < m_vecFHS.size())
+	{
+		string strTemp = m_vecFHS.at(m_indexRoundRobin);
+		// 인덱스 오버플로우를 막기 위함.
+		m_indexRoundRobin++;
+		m_indexRoundRobin %= m_vecFHS.size();
+
+		++iCheckCount;
+
+		// ignore list에 속해 있는 것은 skip 해야한다.
+		// - 추출된 FHS 가 Ignore 목록에 포함되지 않은 경우에만 결과 vector 에 add 처리
+		itIgnore = std::find( listIgnoreFhs.begin(), listIgnoreFhs.end(), strTemp );
+		if( itIgnore == listIgnoreFhs.end() )
+		{
+			// 해당 결과 값이 ignore FHS 항목에 포함되지 않은 경우..
+			// 결과 변수에 Push 처리.
+			vecRet.push_back( strTemp );
+		}
+	}
+	
+	// Lock 해제
+	pthread_mutex_unlock( &m_mutexLock );
+
+	// 요청한 nCount 만큼 결과 변수에 저장했는지 확인..
+	// - 요청 수 만큼 저장한 경우.. true 반환.
+	// - 요청 수 만큼은 아니지만.. 일부 Data 가 저장된 경우에는 false 반환.
+	if( nCount == vecRet.size() )
+		return true;
+	else
+		return false;
+}

rcts/rc_rmcd/src/ProperFhs.h

@@ -0,0 +1,97 @@
+/***************************************************************************
+                Proper FHS management class
+                -----------------------------------------
+    begin      : 2010/03/31
+    copyright  : (C) 2010 Solbox Inc.
+    author     : storage dev team
+    email      : storage.sd@solbox.com
+    version    : 3.3
+
+    CopyRight(C) 2010 Solbox Inc. All Rights reserved.
+    Redistribution and use in source and binary forms, with or with out
+    modification, are not permitted in outside of Solbox Inc.
+***************************************************************************/
+
+#ifndef __PROPER_FHS_H__
+#define __PROPER_FHS_H__
+
+
+#include <vector>
+#include <list>
+#include <string>
+#include <pthread.h>
+
+#include "RcdbInfo.h"
+
+
+// CProperFhs
+// RCDB t_fhs_top_status 테이블에 저장된 Available FHS 정보를 주기적으로 갱신 처리
+// 각 모듈에 인터페이스 제공을 통해 Available FHS 정보를 전달.
+class CProperFhs
+{
+	public:
+		
+		// 생성자
+		CProperFhs();
+		
+		// 소멸자
+		~CProperFhs();
+
+		// 객체 초기화 함수		
+		bool Init();
+
+		// thread를 생성하여 업무 flow 를 시작.
+		bool Start();
+				
+		// 현재 저장된 FHS 의 수를 반환.
+		int GetFhsCount();
+
+		// 적절한 FHS들의 정보를 전달한다.
+		// @param [in] nCount FHS정보의 요청 개수.
+		// @param [out] vecRet 적절한 FHS의 host정보를 vector 타입으로 전달 한다.
+		// @param [in] listIgnoreFhs 무시할 host정보를 입력한다.
+		// @return 성공은 return true, 그렇지 않으면 false. 
+		// @note return false를 해도 nCount만큼은 못보내지만 일부 리스트가 전달 될 수 있다.		
+		bool GetProperFhs( unsigned int nCount, std::vector<std::string> &vecRet, std::list<std::string> &listIgnoreFhs );
+		
+	
+	private:
+
+		// available fhs 정보를 저장하기 위한 vector 객체
+		std::vector<std::string> m_vecFHS;
+
+		// 쓰레드 핸들
+		pthread_t m_threadHandle;
+
+		// RCDB 접속 정보를 저장할 변수.
+		CRcdbInfo m_rcdbInfo;
+		
+		// ProperFHS를 RoundRobin으로 순서에 따라 전달 하기 위한 변수
+		int m_indexRoundRobin;
+
+		// lock 처리 관련
+		pthread_mutex_t m_mutexLock;
+
+		// Thread Loop 마다 Sleep Time 정보를 저장하기 위한 변수
+		unsigned int m_uSleep;
+
+			
+	private:
+
+		// 스레드 함수
+		static void* threadFunc( void* arg );
+	
+		// 스레드 내에서 각 loop 단위 처리 호출 함수.
+		bool Execute();
+	
+		// Proper fhs의 목록을 RCDB t_fhs_top_status 에서 조회.
+		// CHG 2014-06-24 huibong
+		// #19042 의 팀회의 결과에 따라
+		// - RCDB 연결 실패 및 Query 오류 발생시 이전 FHS 목록 유지
+		// - RCDB 에서 조회된 Proper FHS 가 없는 경우.. Proper FHS 목록 Clear 처리
+		// - 그외 정상 처리.
+		bool UpdateFromDB();
+		        
+};
+
+#endif // __PROPER_FHS_H__ 

rcts/rc_rmcd/src/RcdbInfo.cpp

@@ -0,0 +1,38 @@
+#include "RcdbInfo.h"
+#include "ServiceConfig.h"
+
+// 생성자..
+CRcdbInfo::CRcdbInfo()
+{
+}
+
+// 소멸자..
+CRcdbInfo::~CRcdbInfo()
+{
+
+}
+
+
+// CServiceConfig Class 에 저장된 RCDB 접속 정보를 가져와 멤버 변수에 저장한다.
+void CRcdbInfo::Load()
+{
+	// CServiceConfig Class 에서 기본적인 설정값에 대해 검사를 수행하므로... 
+	// 본 Class 에서 다시 유효성 검사를 할 필요는 없다.. ( 어차피 유효성 검사 방법이 동일하므로.. )
+
+	// RCDB IP
+	m_strRcdbIp = CServiceConfig::GetInstance()->GetRcdbIp();
+
+	// RCDB Port
+	m_nRcdbPort = CServiceConfig::GetInstance()->GetRcdbPort();
+
+	// RCDB DB Name
+	m_strRcdbName = CServiceConfig::GetInstance()->GetRcdbName();
+
+	// RCDB 접근 계정
+	m_strRcdbAcct = CServiceConfig::GetInstance()->GetRcdbAcct();
+
+	// RCDB 접근 Password.
+	m_strRcdbAcctPw = CServiceConfig::GetInstance()->GetRcdbAcctPw();
+		
+	return;
+}

rcts/rc_rmcd/src/RcdbInfo.h

@@ -0,0 +1,52 @@
+/****************************************************************************
+                RCDB 접속 정보 저장 처리 Class
+                -----------------------------------------
+
+    begin      : 2013/11/13
+    copyright  : (C) 2005 Solbox Inc.
+    author     : Dev 1 Team
+    email      : dev1@solbox.com
+    version    : 3.2.0
+
+    CopyRight(C) 2005 Solbox Inc. All Rights reserved.
+    Redistribution and use in source and binary forms, with or with out
+    modification, are not permitted in outside of Solbox Inc.
+*****************************************************************************/
+
+#ifndef __RCDB_INFO_H__
+#define __RCDB_INFO_H__
+
+
+#include <unistd.h>
+#include <string>
+
+
+/// @brief CRcdbInfo
+/// 본 클래스는 conf 파일에 저장된 RCDB 접속 관련 정보를 저장하기 위한 공용 Class...
+/// 본 클래스를 사용하지 않고... CServiceConfig class 의 Get 함수를 이용하여 RCDB 접속 정보를 처리해도 된다..
+/// 하지만...  RCDB 접속 처리 Class 함수의 string type 변수 사용으로 인해... 여러 모듈에서 반복적인 동일 코드 처리 작업을 수행해야 하므로...
+/// 본 Class 를 통해 코드를 단순화 시킬 목적으로 사용한다.
+class CRcdbInfo
+{
+	public:
+	
+		// 생성 및 소멸자.
+		CRcdbInfo();
+		~CRcdbInfo();
+
+		// CServiceConfig class 에 저장된 RCDB 접속 정보를 멤버 변수에 저장처리한다.
+		void Load( void );
+
+
+	public:
+
+		// 멤버 변수들은 DB 접속을 처리하는 객체에서 직접 Access 해서 사용할 수 있도록 public 으로 구성. ( 편의성 제공 목적)
+		std::string m_strRcdbIp;				// RCDB IP
+		unsigned int m_nRcdbPort;				// RCDB Port
+		std::string m_strRcdbName;				// RCDB DB Name
+		std::string m_strRcdbAcct;				// RCDB 접근 계정
+		std::string m_strRcdbAcctPw;			// RCDB 접근 Password.
+
+};
+
+#endif /* __RCDB_INFO_H__ */

rcts/rc_rmcd/src/ReplicateControl.cpp

@@ -0,0 +1,314 @@
+#include "ReplicateControl.h"
+
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <list>
+#include <vector>
+#include <string>
+
+#include "Logger.h"
+#include "ServiceConfig.h"
+#include "ReplicateThread.h"
+
+// 매 Loop 마다 Sleep 시간 정보 정의 ( sec 단위)
+#define DEFAULT_SLEEP_TIME  2
+#define MAX_SLEEP_TIME      5
+
+
+// 생성자        
+CReplicateControl::CReplicateControl( CProperFhs * pProperFhs
+		, CProcessStatus * pProcessStatus
+		, CDataQueue<CSourceData> * pQueueSource
+		, CDataQueue<CRetryData> * pQueueRetry
+		, CDataQueue<CCompleteData> * pQueueComplete )
+	: m_pProperFhs( pProperFhs )
+		, m_pProcessStatus( pProcessStatus )
+		, m_pSourceQueue( pQueueSource )
+		, m_pRetryQueue( pQueueRetry )
+		, m_pCompleteQueue( pQueueComplete )
+{
+	// 멤버 변수 초기화
+	m_threadHandle = 0;
+
+	m_uSleep = DEFAULT_SLEEP_TIME;
+	m_uRetryCount = 2; // 그냥 기본 설정. Init() 함수에서 실제 값으로 설정 처리함.
+}
+
+// 소멸자
+CReplicateControl::~CReplicateControl()
+{
+	// Thread 동작 정지 처리
+	// - 만약 Thread 가 이미 종료된 경우 m_threadHandle 이 다른 Thread Handle 일 수 있으므로 
+	//   업무 Flow 수정시 주의할 것
+	if( m_threadHandle != 0 )
+		pthread_cancel( m_threadHandle );
+
+}
+
+// 객체 초기화 수행
+bool CReplicateControl::Init()
+{
+	// Report 로그 처리 관련 멤버 객체 초기화.
+	// - retry 재시도에 관련된 로깅 처리 목적	
+	if( m_reportLog.Init( CServiceConfig::GetInstance()->GetLogPath() ) == false )
+	{
+		std::string strErrorMessage;
+		m_reportLog.GetLastError( strErrorMessage );
+
+		LOG( LERR, "report log init fail. [%s]", strErrorMessage.c_str() );
+		return false;
+	}
+	
+	// Queue Pop 제어 관련 멤버 객체 초기화.
+	if( m_controlQueuePop.Init( m_pSourceQueue, m_pRetryQueue ) == false )
+	{
+		LOG( LERR, "CQueuePopControl object init() fail.");
+		return false;
+	}
+
+	// Retry count 값 설정
+	m_uRetryCount = CServiceConfig::GetInstance()->GetMaxRetryCount();
+
+	return true;		
+}
+
+
+// 스레드 내에서 각 loop 단위 처리 호출 함수.
+// return true  : 처리할 Data 가 계속 존재하는 경우...
+//        false : 처리할 Data 가 없어 idle 한 경우.
+bool CReplicateControl::MakeReplication()
+{
+	// 1. CProcessStatus에서 생성 가능한 Replication Thread  수 확인
+	unsigned int nWorkCount = 0;
+	nWorkCount = m_pProcessStatus->GetValidReplicationCount();
+	if( nWorkCount == 0 )
+	{
+		// 생성 가능한 Replication Thrad 수가 없는 경우...
+		// - false 를 반환할 경우... MAX_SLEEP_TIME 만큼 대기하므로... 
+		// - 빠른 시간내에 재시도할 수 있도록 true 를 반환.
+		return true;
+	}
+
+	// 2. Queue 에서 생성 가능한 Thread 수 만큼 Content 정보 pop 처리.
+	std::list<CRetryData> listWork;
+	if( m_controlQueuePop.GetWork( nWorkCount, listWork ) == false )
+	{
+		// Queue 에 작업할 Data 가 존재하지 않는 경우..
+		// - idle 상태
+		return false;
+	}
+
+	// 3. pop 처리된 content 갯수만큼 replication thread 를 생성한다.
+	std::list<std::string> listIgnoreFHS;
+	std::vector<std::string> vecFHS;
+	int nReplicationCount;
+
+	while( listWork.empty() == false )
+	{
+		// list 에서 Data pop
+		CRetryData objRetryData;
+		objRetryData = listWork.front();
+		listWork.pop_front();
+
+		// 제외 대상 FHS 목록을 설정.
+		// - Replication 성공 FHS 와 원본 FHS 를 제외 대상 목록에 포함시킨다.
+		listIgnoreFHS.clear();
+		listIgnoreFHS = objRetryData.m_listSuccessHost;
+		listIgnoreFHS.push_back( objRetryData.m_OriginData.m_szOriginHostName );
+
+		// 복제 횟수 계산.
+		// - 객체에 저장된 복제 설정값에서 재시도 처리를 통해 이미 생성 완료된 값을 뺀다.
+		nReplicationCount = objRetryData.m_OriginData.m_nReplicationCount - objRetryData.m_listSuccessHost.size();
+		if( nReplicationCount <= 0 )
+		{
+			// 복제 count 가 0보다 작은 경우...
+			// - 이상 상황인 경우...
+			// - 복제 작업을 하지 않고 로깅 처리.
+			LOG( LWAR, "Replication count[%d] not vaild.[%s]"
+				, nReplicationCount, objRetryData.m_OriginData.m_szURI.c_str() );
+
+			continue;
+		}
+		
+		// FHS 를 상태를 관리하는 CProperFHS 모듈을 통해
+		// - 복제 가능한 FHS 목록을 추출한다.
+		vecFHS.clear();
+		m_pProperFhs->GetProperFhs( nReplicationCount, vecFHS, listIgnoreFHS );
+
+		// CHG 2014-06-24 huibong
+		// #19042 의 팀회의 결과에 따라
+		// - 서비스의 설정된 복제 갯수보다 proper FHS 수가 적은 경우가 발생 가능. 이에 따라 다음과 같이 처리
+		// - proper FHS 가 0 인 경우 Retry 처리
+		// - proper FHS 수가 적은 경우
+		//   일단 추출된 proper FHS 에 복제본 생성 처리
+		//   향후 신규 개발될 후보정 처리 모듈에서 부족한 복제본에 대한 보정 처리 수행.
+		if( vecFHS.size() == 0 )
+		{
+			// Proper FHS 가 하나도 없는 경우 
+			// - 재시도 횟수가 초과된 경우 Report 로그에 기록 후 삭제 처리.
+			// - 그외 Retry Queue 에 저장 처리
+			if( objRetryData.m_uFailCount + 1 > m_uRetryCount )
+			{
+				// 재시도 횟수 초과
+				_LOG( LERR, "CReplicateControl: proper fhs not exist and retry count over.[%s][%llu]"
+					, objRetryData.m_OriginData.m_szURI.c_str()
+					, objRetryData.m_OriginData.m_nContentLength );
+
+				m_reportLog.Write( "ERR", "[%s][Replication fail. check content[%s][%llu]]"
+					, PROG_NAME
+					, objRetryData.m_OriginData.m_szURI.c_str()
+					, objRetryData.m_OriginData.m_nContentLength );
+			}
+			else
+			{
+				// Retry Queue 에 저장 처리
+				objRetryData.m_uFailCount += 1;
+				objRetryData.m_timeFailed = time( 0 );
+
+				// Retry Queue push 실패 발생 가능
+				// - Retry Queue 가 full 인 경우 push 실패 
+				// - 만약 무작정 push 될때까지 루프를 돌리면... 
+				// - 본 Control 모듈에서 pop을 할 수 없어 무한 대기가 발생하므로.. 
+				// - Push 실패 발생시 report 로그에 기록하고 버린다.
+				if( m_pRetryQueue->Push( objRetryData ) == false )
+				{
+					_LOG( LERR, "CReplicateControl: proper fhs not exist and retry queue push fail.[%s][%llu]"
+						, objRetryData.m_OriginData.m_szURI.c_str()
+						, objRetryData.m_OriginData.m_nContentLength );
+										
+					m_reportLog.Write( "ERR", "[%s][Replication fail by retry queue full.check conf[%s][%llu]]"
+						, PROG_NAME
+						, objRetryData.m_OriginData.m_szURI.c_str()
+						, objRetryData.m_OriginData.m_nContentLength );
+				}
+				else
+				{
+					_LOG( LWAR, "CReplicateControl: proper fhs not exist. retry add.[%s][%llu]"
+						, objRetryData.m_OriginData.m_szURI.c_str()
+						, objRetryData.m_OriginData.m_nContentLength );
+				}
+			}
+
+			// 다음 Content 에 대해 계속 수행.
+			continue;
+		}
+
+		// 복제 Thread 생성
+		// - 이 곳에서는 new로 할당만 처리.
+		// - CReplicateThread가 종료될때 delete this를 하기때문이니 놀라지말것.
+		CReplicateThread * pReplicateThread 
+			= new CReplicateThread( m_pProcessStatus, m_pRetryQueue
+			                      , m_pCompleteQueue, objRetryData, vecFHS );
+
+		// Thread 생성 또는 Start 실패의 경우
+		// - Retry Queue 에 저장 처리.
+		if( pReplicateThread == NULL || pReplicateThread->Start() == false )
+		{
+			// 최종 Thread 정리
+			if( pReplicateThread != NULL )
+			{
+				delete pReplicateThread;
+				pReplicateThread = NULL;
+			}
+
+			// 재시도 횟수가 초과된 경우 Report 로그에 기록 후 삭제 처리.
+			if( objRetryData.m_uFailCount + 1 > m_uRetryCount )
+			{
+				// 재시도 횟수 초과
+				_LOG( LERR, "CReplicateControl: replicate thread start fail and retry count over.[%s][%llu]"
+					, objRetryData.m_OriginData.m_szURI.c_str()
+					, objRetryData.m_OriginData.m_nContentLength );
+
+				m_reportLog.Write( "ERR", "[%s][Replication fail. check content[%s][%llu]]"
+					, PROG_NAME
+					, objRetryData.m_OriginData.m_szURI.c_str()
+					, objRetryData.m_OriginData.m_nContentLength );
+			}
+			else
+			{
+				// Retry Queue 에 저장 처리
+				objRetryData.m_uFailCount += 1;
+				objRetryData.m_timeFailed = time( 0 );
+
+				// Retry Queue push 실패 발생 가능
+				// - Retry Queue 가 full 인 경우 push 실패 
+				// - 만약 무작정 push 될때까지 루프를 돌리면... 
+				// - 본 Control 모듈에서 pop을 할 수 없어 무한 대기가 발생하므로.. 
+				// - Push 실패 발생시 report 로그에 기록하고 버린다.
+				if( m_pRetryQueue->Push( objRetryData ) == false )
+				{
+					_LOG( LERR, "CReplicateControl: proper fhs not exist and retry queue push fail.[%s][%llu]"
+						, objRetryData.m_OriginData.m_szURI.c_str()
+						, objRetryData.m_OriginData.m_nContentLength );
+
+					m_reportLog.Write( "ERR", "[%s][Replication fail by retry queue full.check conf[%s][%llu]]"
+						, PROG_NAME
+						, objRetryData.m_OriginData.m_szURI.c_str()
+						, objRetryData.m_OriginData.m_nContentLength );
+				}
+				else
+				{
+					_LOG( LWAR, "CReplicateControl: replicate thread start fail. retry add.[%s][%llu]"
+						, objRetryData.m_OriginData.m_szURI.c_str()
+						, objRetryData.m_OriginData.m_nContentLength );
+				}
+			}
+		}		
+	}
+
+	// Pop 한 Content 에 대해 처리가 모두 완료 된 경우...
+	return true;
+}
+
+// 스레드 내에서 각 loop 단위 처리 호출 함수.
+void CReplicateControl::Execute()
+{
+	if( MakeReplication() == true )
+	{
+		m_uSleep = DEFAULT_SLEEP_TIME;
+	}
+	else
+	{
+		m_uSleep = MAX_SLEEP_TIME;
+	}
+}
+
+// 스레드 함수
+void* CReplicateControl::threadFunc( void* arg )
+{
+    CReplicateControl* pObject = reinterpret_cast<CReplicateControl *>(arg);    
+	pthread_detach( pthread_self() );
+    
+    while( 1 )
+    {
+        pthread_testcancel();
+        pObject->Execute();
+        pthread_testcancel();
+
+		sleep( pObject->m_uSleep );
+    }
+
+	// NEW 2014-06-23 huibong
+	// Thread 종료시 m_threadHandle 값을 초기화 처리.
+	// - 소멸자에서 잘못된 Thread 를 종료할 수 있기 때문.
+	pObject->m_threadHandle = 0;
+    	
+	return NULL;
+}
+
+// thread를 생성하여 업무 flow 를 시작.
+bool CReplicateControl::Start()
+{    
+	int nRet = ::pthread_create( &m_threadHandle, NULL, CReplicateControl::threadFunc, this );
+	if( nRet != 0 )
+	{
+		// Thread 생성 실패시
+		int errorNum = errno;
+		LOG( LERR, "Thread create failed.[%d][%s]", errorNum, strerror( errorNum ) );
+
+		return false;
+	}
+	
+	return true;
+}

rcts/rc_rmcd/src/ReplicateControl.h

@@ -0,0 +1,104 @@
+/***************************************************************************
+                Replicate Control class
+                -----------------------------------------
+    begin      : 2010/03/31
+    copyright  : (C) 2010 Solbox Inc.
+    author     : storage dev team
+    email      : storage.sd@solbox.com
+    version    : 3.3
+
+    CopyRight(C) 2010 Solbox Inc. All Rights reserved.
+    Redistribution and use in source and binary forms, with or with out
+    modification, are not permitted in outside of Solbox Inc.
+***************************************************************************/
+
+#ifndef __REPLICATE_CONTROL_H__
+#define __REPLICATE_CONTROL_H__
+
+#include <pthread.h>
+
+#include "ProperFhs.h"
+#include "ProcessStatus.h"
+#include "DataQueue.hpp"
+#include "ReplicationData.h"
+#include "ReportLog.h"
+#include "ReplicateQueueControl.h"
+
+
+// CReplicateControl
+// Replication 관련 각 Thread 및 Queue 를 제어하여...
+// 전체적으로 Replication 생성 업무 Flow 를 제어한다.
+// 내부적으로 Thread를 사용
+class CReplicateControl
+{
+    public:
+
+        // 생성자        
+        CReplicateControl( CProperFhs * pProperFhs
+						, CProcessStatus * pProcessStatus
+						, CDataQueue<CSourceData> * pQueueSource
+						, CDataQueue<CRetryData> * pQueueRetry
+						, CDataQueue<CCompleteData> * pQueueComplete );
+
+		// 소멸자
+        ~CReplicateControl();
+        
+		// 객체 초기화 수행
+		bool Init();
+
+		// thread를 생성하여 업무 flow 를 시작.
+        bool Start();
+        
+
+    private:
+
+		// Proper FHS 정보를 관리하는 CProperFhs 객체에 대한 포인터.
+		// - 생성자를 통해 전달받음.
+		CProperFhs * m_pProperFhs;
+
+		// 프로세스 상의 Queue, Thread 상태를 관리하는 CProcessStatus 객체에 대한 포인터
+		// - 생성자를 통해 전달받음        
+		CProcessStatus * m_pProcessStatus;
+
+		// 복제대상 Content 정보를 관리하는 Queue 객체에 대한 포인터
+		// - 생성자를 통해 전달받음        
+		CDataQueue<CSourceData> * m_pSourceQueue;
+
+		// 복제 처리 관련 재시도 Content 정보를 관리하는 Queue 객체에 대한 포인터
+		// - 생성자를 통해 전달받음
+		CDataQueue<CRetryData> * m_pRetryQueue;
+
+		// 복제 완료된 Content 정보를 관리하는 Queue 객체에 대한 포인터
+		// - 생성자를 통해 전달받음
+		CDataQueue<CCompleteData> * m_pCompleteQueue;
+
+		// 스레드 핸들
+		pthread_t m_threadHandle;
+
+		// Report log 처리 관련 객체
+		CReportLog m_reportLog;
+
+		// Thread Loop 마다 Sleep Time 정보를 저장하기 위한 변수
+		unsigned int m_uSleep;
+
+		// conf 에 설정된 Replication Retry count 정보를 저장하기 위한 멤버 변수
+		unsigned int m_uRetryCount;
+		
+		// Queue Pop 처리를 담당할 멤버 객체
+		CReplicateQueueControl m_controlQueuePop;
+		
+
+	private:
+        
+		// 스레드 함수
+		static void* threadFunc( void* arg );
+        
+		// 스레드 내에서 각 loop 단위 처리 호출 함수.
+        void Execute();
+
+		// Replication 생성 처리를 수행하기 위한 함수.
+		bool MakeReplication();
+
+
+};
+#endif //__REPLICATE_CONTROL_H__

rcts/rc_rmcd/src/ReplicateInsert.cpp

@@ -0,0 +1,671 @@
+#include "ReplicateInsert.h"
+
+#include <errno.h>
+#include <string.h>
+
+#include "Logger.h"
+#include "Database.h"
+#include "ServiceConfig.h"
+#include "Util.h"
+
+
+// 처리 loop 간의 sleep time 정의
+// - 매 지정된 sec 마다 queue 를 검사하여 RCDB 에 저장 처리.
+#define DEFAULT_SLEEP_TIME  3
+// RCDB 접속 실패 또는 Query 실패 등의 상황 발생시 
+#define MAX_SLEEP_TIME     30
+
+// Query 문장 저장을 위한 Buffer 크기
+#define DEFAULT_QUERY_BUFFER_SIZE 2048
+
+
+// 생성자
+// @param [in] pCCompleteData replication 완료 content 정보를 저장하는 queue
+CReplicateInsert::CReplicateInsert( CDataQueue<CCompleteData> * pCompleteQueue )
+	: m_pCompleteQueue( pCompleteQueue )
+{
+	m_threadHandle = 0;
+
+	m_uSleep = DEFAULT_SLEEP_TIME;
+
+	// NEW 2014-06-16 신규 멤버 변수 초기화 코드 추가.
+	// Init() 에서 RCDB 접속 실패가 발생 가능하므로.. 구형 RCDB 형상을 사용토록 설정.
+	m_bServiceTableSeparate = false;
+}
+
+// 소멸자
+CReplicateInsert::~CReplicateInsert()
+{
+	// Thread 동작 정지 처리
+	// - 만약 Thread 가 이미 종료된 경우 m_threadHandle 이 다른 Thread Handle 일 수 있으므로 
+	//   업무 Flow 수정시 주의할 것
+	if( m_threadHandle != 0 )
+		pthread_cancel( m_threadHandle );
+}
+
+// 초기화 작업 수행
+bool CReplicateInsert::Init()
+{
+	// 생성자를 통해 전달받은 queue 포인터가 NULL 인 경우... 오류 처리
+	if( m_pCompleteQueue == NULL )
+	{
+		LOG( LERR, "replication complete queue is null" );
+		return false;
+	}
+
+	// Report log 를 처리할 객체 초기화.
+	if( m_reportLog.Init( CServiceConfig::GetInstance()->GetLogPath() ) == false )
+	{
+		std::string strErrorMessage;
+		m_reportLog.GetLastError( strErrorMessage );
+
+		LOG( LERR, "report log init fail. [%s]", strErrorMessage.c_str() );
+		return false;
+	}
+	
+	// RCDB 접속 정보 Load.
+	m_rcdbInfo.Load();
+
+	// RCDB 접속 처리를 위한 객체 생성
+	DataBase rcdb;
+
+	// RCDB 접속 시도 및 접속 실패시
+	if( rcdb.PgOpenDB( m_rcdbInfo.m_strRcdbIp, m_rcdbInfo.m_nRcdbPort
+		, m_rcdbInfo.m_strRcdbName, m_rcdbInfo.m_strRcdbAcct
+		, m_rcdbInfo.m_strRcdbAcctPw ) == NULL )
+	{
+		LOG( LERR, "RCDB connection failed." );
+		return false;
+	}
+	else
+	{
+		// 접속 성공한 경우...
+		LOG( LINF, "RCDB connection test ok..." );
+
+		// NEW 2014-06-19 huibong
+		// 서비스 table 분리된 신규 형상인지.. 구형 형상인지 체크하여
+		// m_bServiceTableSeparate 변수 설정 처리.
+		// 해당 변수 초기화는 생성자에서 1차로 수행함.
+		char szQuery[1024];
+		snprintf( szQuery, 1023,
+			"SELECT * FROM pg_tables WHERE schemaname = 'public' AND tablename = 't_dav_resource' " );
+
+		rcdb.PgDoExec( szQuery );
+		if( rcdb.PgResult( DataBase::NOT_CLEAR ) < 0 )
+		{
+			// Query 수행 결과 오류 발생시...
+			// - pg_tables 가 존재하지 않을 경우 오류 발생 가능...
+			// - 이는 RCDB 가 아직 적절하게 구성되지 않았다는 의미이므로... Init()함수를 오류로 처리한다.
+			LOG( LERR, "RCDB t_dav_resource exist check failed.[%s][%s]", rcdb.GetErrorMessage().c_str(), szQuery );
+
+			rcdb.PgClear();
+			rcdb.PgCloseDB();
+
+			return false;
+		}
+		else
+		{
+			// Query 수행이 정상인 경우.
+			int  nResult = rcdb.GetNoTuples();
+			if( nResult > 0 )
+			{
+				// t_dav_resource 테이블이 존재하는 경우...
+				m_bServiceTableSeparate = false;
+				_LOG( LINF, "CReplicateInsert: t_dav_resource table exist.[Old RCDB Type]" );
+			}
+			else
+			{
+				// t_dav_resource 테이블이 존재하지 않는 서비스별 테이블 분리 형상인 경우.
+				m_bServiceTableSeparate = true;
+				_LOG( LINF, "CReplicateInsert: t_dav_resource table not exist.[New RCDB Type]" );
+			}
+		}
+
+		// RCDB 조회 결과 set 를 clear 처리 후 RCDB 접속 해제.
+		rcdb.PgClear();
+		rcdb.PgCloseDB();
+
+		return true;
+	}    
+}
+
+// Thread 를 생성하여 할당된 작업을 수행.
+bool CReplicateInsert::Start()
+{
+	int nRet = ::pthread_create( &m_threadHandle, NULL, CReplicateInsert::threadFunc, this );
+	if( nRet != 0 )
+	{
+		// Thread 생성 실패시
+		int errorNum = errno;
+		LOG( LERR, "Thread create failed.[%d][%s]", errorNum, strerror( errorNum ) );
+
+		return false;
+	}
+
+	return true;
+}
+
+// Thread function
+void* CReplicateInsert::threadFunc( void* arg )
+{
+	CReplicateInsert* pObject = reinterpret_cast<CReplicateInsert *>( arg );
+	pthread_detach( pthread_self() );
+
+	while( 1 )
+	{
+		pthread_testcancel();
+		pObject->Execute();
+		pthread_testcancel();
+
+		// 1회 수행 후 지정된 시간 만큼 대기
+		sleep( pObject->m_uSleep );
+	}
+
+	// NEW 2014-06-19 huibong
+	// Thread 종료시 m_threadHandle 값을 초기화 처리.
+	// - 소멸자에서 잘못된 Thread 를 종료할 수 있기 때문.
+	pObject->m_threadHandle = 0;
+
+	return NULL;
+}
+
+// 스레드 내에서 각 loop 단위 처리 호출 함수.
+void CReplicateInsert::Execute()
+{
+	// Queue 상에 처리할 Data 가 존재할 경우...	
+	if( m_pCompleteQueue->GetSize() > 0 )
+	{
+		bool bResult;
+
+		// t_dav_resource 테이블 사용 형상인 경우.
+		if( m_bServiceTableSeparate == false )
+		{
+			bResult = InsertToOldDB();
+		}
+		else
+		{
+			// 서비스별 Table 이 분리된 신규 형상인 경우.
+			bResult = InsertToDB();
+		}
+
+		// 처리 결과에 따라 loop sleep time 조정
+		if( bResult == true )
+			m_uSleep = DEFAULT_SLEEP_TIME;
+		else
+		{
+			// RCDB 연결 실패, Queury 수행 실패 등의 오류 발생시
+			m_uSleep = MAX_SLEEP_TIME;
+		}
+	}
+	else
+	{
+		// queue 상에 처리할 Data 가 존재하지 않는 경우.
+		m_uSleep = DEFAULT_SLEEP_TIME;
+	}
+}
+
+// RCDB 상에 복제 완료된 content 정보를 insert 처리한다. ( t_dav_resource 사용 )
+bool CReplicateInsert::InsertToOldDB()
+{
+	// 1. RCDB 와 연결 처리.
+	DataBase rcdb;
+	if( rcdb.PgOpenDB( m_rcdbInfo.m_strRcdbIp, m_rcdbInfo.m_nRcdbPort
+		, m_rcdbInfo.m_strRcdbName, m_rcdbInfo.m_strRcdbAcct
+		, m_rcdbInfo.m_strRcdbAcctPw ) == NULL )
+	{
+		// RCDB 접속이 실패
+		LOG( LERR, "RCDB connection failed." );
+		return false;		
+	}
+	
+	// 2. 루프를 돌면서 queue 에 저장된 data 를 처리한다.
+	
+	// queue 에서 꺼낸 정보를 저장하기 위한 변수
+	CCompleteData resultData;	
+	// Query 문장 저장을 위한 버퍼 생성
+	char szQuery[DEFAULT_QUERY_BUFFER_SIZE];
+	// Query 수행 결과값 저장을 위한 변수..	
+	int nResult = 0;
+
+	while( m_pCompleteQueue->GetSize() > 0 )	
+	{
+		// queue 에 저장된 첫번째 data 복사 (queue 에서 삭제된 상태 아님)		
+		resultData = m_pCompleteQueue->Front();
+		
+		// URI의 '(작은따옴표) 문자가 있을 경우 SQL 오류 방지를 위하여 관련 문자를 다르게 변경함
+		std::string orgURI = stringreplace(resultData.m_OriginData.m_szURI, "'", "''");
+		
+		// 원본 조회 서브 쿼리 절에서 분리함 2012.02.10
+		// PGPool 경우 INSERT~SELECT 사용 지향
+		// 해당 서브절에 SELECT 값이 DB01,DB02 서로 다른 값을 참조될 수 있다.
+	
+		// 3. 원본 존재 여부 확인
+		// Replication 처리가 완료된 Content 에 대해 meta 정보 입력전 실제 원본이 존재하는지 확인한다.
+		sprintf( szQuery,
+				"SELECT "
+				"  sp_user_seq, sp_svc_tran_id, "
+				"  '%s', "
+				"  resource_type, uri, filename_org, '%s', "
+				"  depth, display_name, get_content_language, "
+				"  get_content_length, get_content_type, "
+				"  get_etag, get_lastmodified, creation_date, "
+				"  lock_discovery, source, supported_lock, deleted_yn, 'R', file_lastmodified " // is_cache = R
+				"FROM t_dav_resource "
+				"WHERE filename_hash = '%s' "
+				"AND uri = '%s' "
+				"AND get_content_length = %lld "
+				"AND is_cache = 'N' AND host_name = '%s' ;",
+				resultData.m_szTargetHostName.c_str(),
+				resultData.m_szTargetFileNameHash.c_str(),
+				resultData.m_OriginData.m_szFileNameHash.c_str(), 
+				orgURI.c_str(),
+				resultData.m_OriginData.m_nContentLength,
+				resultData.m_OriginData.m_szOriginHostName.c_str() );
+
+		// Query 수행 및 결과 확인
+		rcdb.PgDoExec( szQuery );
+		nResult = rcdb.PgResult( DataBase::NOT_CLEAR );
+		if( nResult < 0 )
+		{
+			// RCDB t_dav_resource 테이블 조회 실패시
+			// - RCDB 연결 관련 실패시 : nResult = -4
+			// - uri 상의 특수문자로 인해 query 오류 : nResult = -4
+			// - 즉 오류 반환값이 동일하기 때문에 어떠한 문제로 query 가 실패했는지 판단 못함.
+			
+			// 우선 DB 연결 문제일 수 있으므로... 
+			// RCDB 재접속 시도.
+			rcdb.PgClear();
+			rcdb.PgCloseDB();
+			sleep( 1 );
+
+			if( rcdb.PgOpenDB( m_rcdbInfo.m_strRcdbIp, m_rcdbInfo.m_nRcdbPort
+				, m_rcdbInfo.m_strRcdbName, m_rcdbInfo.m_strRcdbAcct
+				, m_rcdbInfo.m_strRcdbAcctPw ) == NULL )
+			{
+				// RCDB 접속 실패 문제인 경우..
+				// - 본 처리 함수 종료 처리하여 다음 loop 에서 재시도토록 처리.
+				LOG( LERR, "select query fail because RCDB connection error. [%d][%s]"
+					, nResult, rcdb.GetErrorMessage().c_str());
+				
+				rcdb.PgCloseDB();
+				return false;
+			}
+			else
+			{
+				// uri 상에 특수 문자 문제로 query 실패시
+				// - Report 로그에 관련 내역 기록
+				// - queue 에서 해당 정보를 삭제 처리한 후 계속 수행한다.
+				LOG( LERR, "select query fail. queue forced pop.[%s][%d][%s]"
+					, orgURI.c_str(), nResult, rcdb.GetErrorMessage().c_str() );
+
+				m_reportLog.Write( "WAR", "[%s][Replication contents RCDB insert fail. check uri.[%s]]"
+					, PROG_NAME, orgURI.c_str());
+
+				rcdb.PgClear();
+				m_pCompleteQueue->Pop();
+				continue;
+			}
+		}
+
+		// 결과 Row 수 확인.
+		nResult = rcdb.GetNoTuples();
+		if( nResult <= 0 )
+		{
+			// Replication 생성된 content 가 RCDB 에 존재하지 않는 경우...
+			// - RCDB 에 저장하지 않고 그냥 버린다.
+			// - 이로 인해 FHS 에 meta 기준으로 삭제 불가능한 파일이 남게 된다.			
+			_LOG( LINF, "Replication content[%s] not found in RCDB.", orgURI.c_str() );
+			
+			rcdb.PgClear();
+			m_pCompleteQueue->Pop();
+			continue;
+		}
+
+		// 조회된 원본 정보를 list 에 저장
+		std::vector<string> srcinfo;
+		std::string strResult;
+		for( int j = 0 ; j < 21; j++ )
+		{
+			strResult = rcdb.GetValue( 0, j );
+			strResult = stringreplace( strResult, "'", "''" );
+			srcinfo.push_back( strResult );
+		}
+
+		// Select Query 의 결과를 Clear 
+		rcdb.PgClear();
+
+		// 4. Replication 된 Content 정보를 Meta 정보로 Insert
+		// INSERT 작업시 앞에서 조회된 원본 정보를 이용하여 INSERT 한다.
+		sprintf( szQuery,
+				"INSERT INTO t_dav_resource "
+				"( "
+				"  sp_user_seq, sp_svc_tran_id, "
+				"  host_name, "
+				"  resource_type, uri, filename_org, filename_hash, "
+				"  depth, display_name, get_content_language, "
+				"  get_content_length, get_content_type, "
+				"  get_etag, get_lastmodified, creation_date, "
+				"  lock_discovery, source, supported_lock, deleted_yn, is_cache ,file_lastmodified) "
+				"VALUES "
+				"( "
+				"  %s, %s, "
+				"  '%s', "
+				"  %s, '%s', '%s', '%s', "
+				"  %s, '%s', '%s', "
+				"  %s, '%s', "
+				"  '%s', %s, %s, "
+				"  '%s', %s, '%s', '%s', '%s', %s );", // is_cache = R
+				srcinfo[0].c_str(),srcinfo[1].c_str(),srcinfo[2].c_str(),srcinfo[3].c_str(),
+				srcinfo[4].c_str(),srcinfo[5].c_str(),srcinfo[6].c_str(),srcinfo[7].c_str(),
+				srcinfo[8].c_str(),srcinfo[9].c_str(),srcinfo[10].c_str(),srcinfo[11].c_str(),
+				srcinfo[12].c_str(),srcinfo[13].c_str(),srcinfo[14].c_str(),srcinfo[15].c_str(),
+				srcinfo[16].c_str(),srcinfo[17].c_str(),srcinfo[18].c_str(),srcinfo[19].c_str(),srcinfo[20].c_str()
+				);
+
+		// INSERT query 수행
+		rcdb.PgDoExec( szQuery );
+		nResult = rcdb.PgResult( DataBase::CLEAR );
+		if( nResult  < 0 )
+		{
+			// RCDB INSERT 작업시 오류가 발생한 경우...
+			// - uri 문제는 앞의 SELECT query 에서 체크했으므로 아니고....
+			// - DB 연결 문제 역시 바로 앞에서 체크 했으므로 아닐 가능성이 큼.
+			// - 가장 큰 오류는 Query 오류일 가능성이 크므로...
+			// - Queue 에 pop 처리한다.
+			
+			// Report 로그에 관련 내역 기록
+			LOG( LERR, "insert query fail. queue forced pop.[%s][%d][%s]"
+				, orgURI.c_str(), nResult, rcdb.GetErrorMessage().c_str() );
+
+			m_reportLog.Write( "WAR", "[%s][Replication contents RCDB insert fail. Check query[%s][%s]]"
+				, PROG_NAME, orgURI.c_str(), rcdb.GetErrorMessage().c_str() );
+
+			// queue 에서 해당 정보를 삭제 처리한 후 계속 수행한다.
+			rcdb.PgClear();
+			m_pCompleteQueue->Pop();
+			continue;			
+		}
+
+		rcdb.PgClear();
+
+		// NEW 2012-09-24 huibong Replication 최종 정합성 검증 기능 추가
+		// 원본 존재 여부를 확인한 후 Insert 를 수행하지만...
+		// 해당 interval 동안 원본이 MOVE 또는 Rename, Delete 되는 상황이 발생하여  잘못된 Replication이 발생하고..이로 인해 서비스 장애가 발생 가능
+		// INSERT 작업 후 원본에 대한 정합성 여부를 다시 한번 확인하여 
+		// 원본이 변경된 경우 INSERT 된 Meta 정보를 DELETE 처리한다.
+
+		// 5. INSERT 된 Meta 정보에 대해 원본이 존재하는지 다시 한번 확인하여
+		// 원본이 변경된 경우 INSERT 된 정보를 DELETE 한다. (deleted_yn = 'Y', 물리 Content 자동 제거 처리 목적 )
+		sprintf( szQuery,
+				"SELECT "
+				"  uri, get_content_length, deleted_yn "
+				"FROM t_dav_resource "
+				"WHERE filename_hash = '%s' "
+				"AND uri = '%s' "
+				"AND get_content_length = %lld "
+				"AND is_cache = 'N' AND host_name = '%s' AND deleted_yn = '%s' ;",
+				resultData.m_OriginData.m_szFileNameHash.c_str(), 
+				orgURI.c_str(),
+				resultData.m_OriginData.m_nContentLength,
+				resultData.m_OriginData.m_szOriginHostName.c_str(),
+				srcinfo[18].c_str()
+				);
+
+		rcdb.PgDoExec( szQuery );
+		nResult = rcdb.PgResult( DataBase::NOT_CLEAR );
+		if( nResult < 0 )
+		{
+			// 최종 검증을 위한 Check query 가 실패한 경우..
+			// query 구문은 앞의 2번 query 를 통해 검증되었으므로.. query 문제가 아닐 듯.
+			// 본 오류는 대부분 RCDB 연결 관련 문제인 듯.
+			// - 로깅 처리 후
+			// - RCDB 에 이미 INSERT 처리 되었으므로... queue pop 처리
+			// - DB 세션 종료 처리 후 .. return 하여.. sleep 후 다음 루프가 동작하도록 처리.
+			LOG(LERR, "replication last check query fail.[%s][%d][%s][%s]"
+				, orgURI.c_str(), nResult, rcdb.GetErrorMessage().c_str(), szQuery );
+
+			rcdb.PgClear();
+			rcdb.PgCloseDB();
+
+			m_pCompleteQueue->Pop();
+			return false;			
+		}
+
+		// 조회된 결과 row 수 확인
+		nResult = rcdb.GetNoTuples();
+		rcdb.PgClear();
+
+		if( nResult <= 0 )
+		{
+			// 원본이 변경된 경우......
+			// 앞에서 INSERT 된 Replication 정보를 deleted_yn = 'Y' 처리한다.
+			LOG( LWAR, "replication check source not found. insert replication value set deleted [%s]"
+				, orgURI.c_str() );
+
+			sprintf( szQuery,
+					"UPDATE t_dav_resource SET deleted_yn = 'Y', get_lastmodified = %lld "
+					"WHERE uri = '%s' "
+					"  AND host_name = '%s' "
+					"  AND filename_hash = '%s' "
+					"  AND get_content_length = %lld "
+					"  AND is_cache = 'R' "
+					"  AND deleted_yn = 'N' ;",
+					longtime_now(),
+					orgURI.c_str(),
+					resultData.m_szTargetHostName.c_str(),
+					resultData.m_szTargetFileNameHash.c_str(),
+					resultData.m_OriginData.m_nContentLength );
+			
+			rcdb.PgDoExec( szQuery );
+			nResult = rcdb.PgResult( DataBase::CLEAR );
+			if( nResult < 0 )
+			{
+				// 삭제 처리 작업이 실패한 경우...
+				// RCDB 연결 문제로 인한 가능성이 가장 크므로...
+				// - 로깅 후..
+				// - RCDB 연결 해제...
+				// - queue pop 후 다음 루프에서 처리토록 return 처리.
+				LOG( LERR, "invalid replication delete fail.[%s][%s]"
+					, orgURI.c_str(), rcdb.GetErrorMessage().c_str());
+
+				m_reportLog.Write( "WAR", "[%s][Invalid replication contents exist.[%s]]"
+					, PROG_NAME, orgURI.c_str() );
+
+				rcdb.PgClear();
+				rcdb.PgCloseDB();
+
+				m_pCompleteQueue->Pop();
+				return false;
+			}
+		}
+
+		// 1 개 replication content 에 대한 RCDB insert 작업이 완료된 경우.
+		// - RCDB clear 처리후
+		// - queue pop.		
+		rcdb.PgClear();
+		m_pCompleteQueue->Pop();
+
+		_LOG( LDBG, "replication rcdb Insert [%s|%s]->[%s|%s|%llu]"
+			, resultData.m_OriginData.m_szOriginHostName.c_str()
+			, resultData.m_OriginData.m_szURI.c_str()
+			, resultData.m_szTargetHostName.c_str()
+			, resultData.m_szTargetFileNameHash.c_str()
+			, resultData.m_OriginData.m_nContentLength 
+			);
+	}
+
+	// queue 에 저장된 정보 처리 작업이 완료된 경우...
+	// - RCDB 연결 해제 처리.
+	rcdb.PgClear();
+	rcdb.PgCloseDB();
+
+	return true;
+}
+
+// RCDB 상에 복제 완료된 content 정보를 insert 처리한다. ( t_meta_xxx 사용 )
+// - 신규 RCDB 관련 미사용 Column 항목 제거 처리.
+bool CReplicateInsert::InsertToDB()
+{
+	// 1. RCDB 와 연결 처리.
+	DataBase rcdb;
+	if( rcdb.PgOpenDB( m_rcdbInfo.m_strRcdbIp, m_rcdbInfo.m_nRcdbPort
+		, m_rcdbInfo.m_strRcdbName, m_rcdbInfo.m_strRcdbAcct
+		, m_rcdbInfo.m_strRcdbAcctPw ) == NULL )
+	{
+		// RCDB 접속이 실패
+		LOG( LERR, "RCDB connection failed." );
+		return false;
+	}
+
+	// 2. 루프를 돌면서 queue 에 저장된 data 를 처리한다.
+
+	// queue 에서 꺼낸 정보를 저장하기 위한 변수
+	CCompleteData resultData;
+	// Query 문장 저장을 위한 버퍼 생성
+	char szQuery[DEFAULT_QUERY_BUFFER_SIZE];
+	// Query 수행 결과값 저장을 위한 변수..	
+	int nResult = 0;
+
+	while( m_pCompleteQueue->GetSize() > 0 )	
+	{
+		// queue 에 저장된 첫번째 data 복사 (queue 에서 삭제된 상태 아님)		
+		resultData = m_pCompleteQueue->Front();
+
+		// URI의 '(작은따옴표) 문자가 있을 경우 SQL 오류 방지를 위하여 관련 문자를 다르게 변경함
+		std::string orgURI = stringreplace( resultData.m_OriginData.m_szURI, "'", "''" );
+
+		// 원본 조회 서브 쿼리 절에서 분리함 2012.02.10
+		// PGPool 경우 INSERT~SELECT 사용 지향
+		// 해당 서브절에 SELECT 값이 DB01,DB02 서로 다른 값을 참조될 수 있다.
+
+		// CHG 2015-02-12 huibong 
+		// 신규 RCDB 형상에 맞도록 처리 Flow 단순화 (#21354)
+		// - RCDB 구조가 pgpool -> streaming replicaton 구조로 변경됨
+		// - 이에 따라 기존 SELECT 후 INSERT, 검수, DELETE flow 에 대한 단순화 가능함.
+
+		sprintf( szQuery,
+				 "INSERT INTO t_meta_%s "                       // 신형 RCDB 형상
+				 "( "
+				 "  sp_user_seq, sp_svc_tran_id, "
+				 "  host_name, "
+				 "  resource_type, uri, filename_org, filename_hash, "
+				 "  depth, display_name, "
+				 "  get_content_length, get_content_type, "
+				 "  get_lastmodified, creation_date, "
+				 "  source, deleted_yn, is_cache , file_lastmodified "
+				 ") "
+				 "SELECT "
+				 "  sp_user_seq, sp_svc_tran_id, "
+				 "  '%s', "
+				 "  resource_type, uri, filename_org, '%s', "
+				 "  depth, display_name, "
+				 "  get_content_length, get_content_type, "
+				 "  get_lastmodified, creation_date, "
+				 "  source, deleted_yn, 'R', file_lastmodified " // is_cache = R
+				 "FROM t_meta_%s "                               // 신형 RCDB 형상
+				 "WHERE filename_hash = '%s' "
+				 "AND uri = '%s' "
+				 "AND get_content_length = %lld "
+				 "AND is_cache = 'N' AND host_name = '%s' ;"
+				 , resultData.m_OriginData.m_szServiceSeq.c_str()
+				 , resultData.m_szTargetHostName.c_str()
+				 , resultData.m_szTargetFileNameHash.c_str()
+				 , resultData.m_OriginData.m_szServiceSeq.c_str()
+				 , resultData.m_OriginData.m_szFileNameHash.c_str()
+				 , orgURI.c_str()
+				 , resultData.m_OriginData.m_nContentLength
+				 , resultData.m_OriginData.m_szOriginHostName.c_str() 
+		);
+
+		// INSERT-SELECT query 수행
+		rcdb.PgDoExec( szQuery );
+		nResult = rcdb.PgResult( DataBase::NOT_CLEAR );
+		if( nResult  < 0 )
+		{
+			// RCDB SELECT-INSERT 작업시 오류가 발생한 경우...
+			// - RCDB 연결 관련 실패시 : nResult = -4
+			// - uri 상의 특수문자로 인해 query 오류 : nResult = -4
+			// - 그외 Query 오류일 가능성이 존재
+
+			std::string strPreviousErrorMessage = rcdb.GetErrorMessage();
+			
+			// 우선 DB 연결 문제일 수 있으므로... RCDB 재접속 시도.
+			rcdb.PgClear();
+			rcdb.PgCloseDB();
+			sleep( 1 );
+
+			if( rcdb.PgOpenDB( m_rcdbInfo.m_strRcdbIp, m_rcdbInfo.m_nRcdbPort
+				, m_rcdbInfo.m_strRcdbName, m_rcdbInfo.m_strRcdbAcct
+				, m_rcdbInfo.m_strRcdbAcctPw ) == NULL )
+			{
+				// RCDB 접속 실패 문제인 경우..
+				// - 본 처리 함수 종료 처리하여 다음 loop 에서 재시도토록 처리.
+				LOG( LERR, "Query fail because New RCDB connection error. [%d][%s]"
+					 , nResult, rcdb.GetErrorMessage().c_str() );
+
+				rcdb.PgCloseDB();
+				return false;
+			}
+			else
+			{
+				// uri 상에 특수 문자 또는 Query 문제인 경우...
+				// - Report 로그에 관련 내역 기록
+				// - queue 에서 해당 정보를 삭제 처리한 후 계속 수행한다.
+								
+				LOG( LERR, "insert-select query fail. queue forced pop.[%s][%d][%s]"
+					 , orgURI.c_str(), nResult, strPreviousErrorMessage.c_str() );
+
+				// Report 로그에 관련 내역 기록 
+				m_reportLog.Write( "WAR", "[%s][Replication contents New RCDB insert fail. Check query[%s][%s]]"
+								   , PROG_NAME, orgURI.c_str(), strPreviousErrorMessage.c_str() );
+
+				rcdb.PgClear();
+				m_pCompleteQueue->Pop();
+				continue;
+			}
+		}
+
+		// PgResult 호출시 NOT_CLEAR 옵션을 사용했으므로....INSERT 수행 row 수 확인을 위해 GetCmdTuples() 함수를 호출가능.
+		nResult = rcdb.GetCmdTuples();
+		if( nResult > 0 )
+		{
+			_LOG( LDBG, "replication rcdb Insert [%d] row, [%s|%s]->[%s|%s|%llu]"
+				  , nResult
+				  , resultData.m_OriginData.m_szOriginHostName.c_str()
+				  , resultData.m_OriginData.m_szURI.c_str()
+				  , resultData.m_szTargetHostName.c_str()
+				  , resultData.m_szTargetFileNameHash.c_str()
+				  , resultData.m_OriginData.m_nContentLength
+			);
+		}
+		else
+		{
+			// INSERT 처리된 row 가 없는 경우....
+			// - 생성된 replicaton 파일은 고아 파일이 됨.
+			_LOG( LWAR, "replication rcdb Insert origin not found. orgin[%s|%s|%llu|%s] orphan[%s|%s|%llu]"
+				  , resultData.m_OriginData.m_szOriginHostName.c_str()
+				  , resultData.m_OriginData.m_szFileNameHash.c_str()
+				  , resultData.m_OriginData.m_nContentLength
+				  , resultData.m_OriginData.m_szURI.c_str()	
+				  , resultData.m_szTargetHostName.c_str()
+				  , resultData.m_szTargetFileNameHash.c_str()
+				  , resultData.m_OriginData.m_nContentLength
+			);
+		}
+
+		
+		// 1 개 replication content 에 대한 RCDB insert 작업이 완료된 경우.
+		// - RCDB clear 처리후
+		// - queue pop.		
+		rcdb.PgClear();
+		m_pCompleteQueue->Pop();
+
+	}
+
+	// queue 에 저장된 정보 처리 작업이 완료된 경우...
+	// - RCDB 연결 해제 처리.
+	rcdb.PgClear();
+	rcdb.PgCloseDB();
+
+	return true;
+}

rcts/rc_rmcd/src/ReplicateInsert.h

@@ -0,0 +1,85 @@
+/***************************************************************************
+                Replication 완료된 Content 정보를 RCDB 에 저장
+                -----------------------------------------
+    begin      : 2010/03/12
+    copyright  : (C) 2010 Solbox Inc.
+    author     : storage dev team
+    email      : storage.sd@solbox.com
+    version    : 3.3
+
+    CopyRight(C) 2010 Solbox Inc. All Rights reserved.
+    Redistribution and use in source and binary forms, with or with out
+    modification, are not permitted in outside of Solbox Inc.
+***************************************************************************/
+
+#ifndef __REPLICATE_INSERT_H__
+#define __REPLICATE_INSERT_H__
+
+#include <pthread.h>
+
+#include "ReplicationData.h"
+#include "DataQueue.hpp"
+#include "RcdbInfo.h"
+#include "ReportLog.h"
+
+
+// CReplicateInsert
+// Replication 생성이 완료된 Conetent 정보를 queue 에서 pop 하여 RCDB 에 저장 처리를 수행
+// 내부적으로 Thread를 사용
+class CReplicateInsert
+{
+    public :
+        
+		// 생성자
+        // @param [in] pCCompleteData replication 완료 content 정보를 저장하는 queue
+		CReplicateInsert( CDataQueue<CCompleteData> * pCCompleteData );
+		// 소멸자
+		~CReplicateInsert();
+        
+        // 초기화
+        bool Init();
+
+        // Thread를 생성하고, 이를 시작한다.        
+        bool Start();
+        
+
+	private :
+        // 스레드 함수
+		static void* threadFunc( void* arg );
+        
+		// RCDB 상에 복제 완료된 content 정보를 insert 처리한다. ( t_dav_resource 사용 )
+		bool InsertToOldDB();
+
+		// RCDB 상에 복제 완료된 content 정보를 insert 처리한다. ( t_meta_xxx 사용 )
+		bool InsertToDB();
+				        
+        void Execute();
+		
+
+	private:
+
+		// 생성자를 통해 전달받은 replication 생성 완료된 content 정보를 저장하는 queue 포인터.
+		CDataQueue<CCompleteData> * m_pCompleteQueue;
+		        
+        // 쓰레드 핸들
+        pthread_t m_threadHandle;
+		
+		// RCDB 접속 정보를 저장할 변수.
+		CRcdbInfo m_rcdbInfo;
+
+		// New 2014-06-19 huibong
+		// RCDB 형상변경에 따라 서비스별 Table 분리 여부 판단 flag
+		// TODO: 향후 신규 RCDB 형상 적용 완료 후 본 항목 제거 필요.
+		// - false : 기존 t_dav_resource 테이블 사용.
+		// - ture  : 신규 RCDB 형상 (서비스별 meta table 분리) 사용.
+		bool m_bServiceTableSeparate;
+
+		// Thread Loop 마다 Sleep Time 정보를 저장하기 위한 변수
+		unsigned int m_uSleep;
+
+		// Report log 처리 관련 객체
+		CReportLog m_reportLog;
+
+};
+
+#endif // __REPLICATE_INSERT_H__

rcts/rc_rmcd/src/ReplicateQueueControl.cpp

@@ -0,0 +1,141 @@
+#include "ReplicateQueueControl.h"
+
+#include <time.h>
+
+#include "Logger.h"
+#include "ServiceConfig.h"
+
+
+// Retry 대상 Content 에 대해 재작업 처리 최소 시간 간격.
+#define RETRY_CHECK_TIME 300  // 5분
+
+
+// 생성자
+CReplicateQueueControl::CReplicateQueueControl()
+{
+	// 멤버 변수 초기화
+	m_pSourceQueue = NULL;
+	m_pRetryQueue  = NULL;
+}
+
+// 소멸자
+CReplicateQueueControl::~CReplicateQueueControl()
+{
+
+}
+
+// 객체 초기화 함수
+bool CReplicateQueueControl::Init( CDataQueue<CSourceData> * pSourceQueue, CDataQueue<CRetryData> * pRetryQueue )
+{
+	// 전달받은 인자를 멤버변수에 할당
+	m_pSourceQueue = pSourceQueue;
+	m_pRetryQueue  = pRetryQueue;
+
+	// Report 로그 처리 관련 멤버 객체 초기화.	
+	if( m_reportLog.Init( CServiceConfig::GetInstance()->GetLogPath() ) == false )
+	{
+		std::string strErrorMessage;
+		m_reportLog.GetLastError( strErrorMessage );
+
+		LOG( LERR, "report log init fail. [%s]", strErrorMessage.c_str() );
+		return false;
+	}
+
+	return true;
+}
+
+// Replication 을 처리할 객체를 요청한 수만큼 list 형태로 전달
+// @param [in] nCnt 요청 개수를 입력한다.
+// @param [out] lstWork 작업대상 정보를 list형태로 전달
+// @return true 처리할 data 가 존재하는 경우..
+//         false 처리할 data 가 없는 경우
+bool CReplicateQueueControl::GetWork(unsigned int nCnt, std::list<CRetryData>& lstWork)
+{
+	// 업무 Flow 상 nCnt == 0 여부는 호출 모듈에서 이미 처리했으므로...
+	// 본 함수에서는 확인하지 않는다.
+
+	// 1. Data 를 저장할 객체 Clear 처리.
+	lstWork.clear();
+	
+	// 2. Retry Queue 상에서 다음 조건을 만족하는 Content 가 존재하는 경우 push 처리
+	//   - 재시도 횟수가 설정값 이하이고... (초과된 경우.. 제거 처리)
+	//   - 지정된 시간 이상 지났는지...
+	//   - Retry Queue 는 특성상 가장 오래된 Data 가 먼저 pop 되므로... 
+	//     위의 조건을 만족하지 않는 Data 가 나타나는 경우... push 를 중지한다.
+	CRetryData objRetryData;
+	time_t timeNow;
+	
+	// Retry Queue 에 Data 가 존재하는 경우..
+	while( m_pRetryQueue->GetSize() > 0 && nCnt > lstWork.size() )
+	{
+		// Retry Queue 에서 첫번째 Data를 가져와.
+		objRetryData = m_pRetryQueue->Front();
+		
+		// 재시도 횟수를 초과했는지 확인		
+		if( objRetryData.m_uFailCount > CServiceConfig::GetInstance()->GetMaxRetryCount() )
+		{
+			// 재시도 횟수를 초과한 경우...
+			// - Report 로그에 내역 기록한 후
+			// - queue 에서 pop 하여 제거 처리
+			_LOG( LERR, "CReplicateQueueControl: retry count over. replication fail.[%s][%llu]"
+				, objRetryData.m_OriginData.m_szURI.c_str()
+				, objRetryData.m_OriginData.m_nContentLength);
+
+			m_reportLog.Write( "ERR", "[%s][Replication fail. check content[%s][%llu]]"
+				, PROG_NAME
+				, objRetryData.m_OriginData.m_szURI.c_str()
+				, objRetryData.m_OriginData.m_nContentLength );
+		
+			m_pRetryQueue->Pop();
+			continue;
+		}
+		
+		// 재시도 가능 시간( Replication 실패 후 지정된 시간 이상 지났는지)인지 확인
+		// - 시간이 지나지 않았다면 더이상 m_pRetryQueue는 조사할 필요가 없다.
+		time(&timeNow);
+		if( objRetryData.m_timeFailed == 0 )
+		{
+			LOG( LERR, "time value is zero. check flow." );		    
+        }
+        
+		if( (timeNow - objRetryData.m_timeFailed) < RETRY_CHECK_TIME )
+		{
+			// 재시도 가능 시간이 아닌 경우.. queue를 그대로 유지하고 loop를 빠져나간다.
+			break;
+		}
+
+		// 재시도 해야 하는 content 인 경우... 
+		// - 결과 변수에 push 처리하고
+		// - retry queue 에서는 pop 하여 제거 처리
+		lstWork.push_back( objRetryData );
+		m_pRetryQueue->Pop();
+	}
+	
+	// 3. Retry Queue 에서 요청한 만큼 Data 를 pop 하지 못한 경우...
+	//    - source queue 에서 pop 처리.	
+	CSourceData objSourceData;
+	while( nCnt > lstWork.size() && m_pSourceQueue->GetSize() > 0 )
+	{
+		// 대상 정보를 가져온다.
+		objSourceData = m_pSourceQueue->Front();
+
+		// list에 넣어주기위해 CRetryData타입으로 생성한다.
+		objRetryData.m_OriginData = objSourceData;
+		objRetryData.m_uFailCount = 0;
+		objRetryData.m_listSuccessHost.clear();
+		objRetryData.m_timeFailed = 0;
+
+		// 결과 변수에 push 처리하고... source queue 에서 pop 처리.
+		lstWork.push_back(objRetryData);
+		m_pSourceQueue->Pop();
+	}
+
+	//_LOG( LINF, "CReplicateQueueControl: queue pop count [%zu]", lstWork.size() );
+
+	// 결과 list 에 data 가 존재하는 경우...
+	if( lstWork.empty() == false )
+		return true;
+	else
+		return false;
+
+}

rcts/rc_rmcd/src/ReplicateQueueControl.h

@@ -0,0 +1,64 @@
+/***************************************************************************
+                Replicationg 관련 Queue Pop Control class
+                -----------------------------------------
+    begin      : 2010/03/31
+    copyright  : (C) 2010 Solbox Inc.
+    author     : storage dev team
+    email      : storage.sd@solbox.com
+    version    : 3.3
+
+    CopyRight(C) 2010 Solbox Inc. All Rights reserved.
+    Redistribution and use in source and binary forms, with or with out
+    modification, are not permitted in outside of Solbox Inc.
+***************************************************************************/
+
+#ifndef __REPLICATE_QUEUE_CONTROL_H__
+#define __REPLICATE_QUEUE_CONTROL_H__
+
+#include <list>
+
+#include "DataQueue.hpp"
+#include "ReplicationData.h"
+#include "ReportLog.h"
+
+
+// CQueuePopControl
+// Replication 처리 관련 원본 Queue 와 재시도 Queue 중
+// 어느 Queue 에서 Replication 대상 content 를 POP 처리할 것인지를 
+// 제어하기 위한 클래스
+class CReplicateQueueControl
+{
+    public:
+        
+		// 생성자
+		CReplicateQueueControl();
+
+		// 소멸자
+		~CReplicateQueueControl();
+        
+		// 객체 초기화 함수
+		bool Init( CDataQueue<CSourceData> * pSourceQueue, CDataQueue<CRetryData> * pRetryQueue );
+        
+
+		// Replication 을 처리할 객체를 요청한 수만큼 list 형태로 전달
+		// @param [in] nCnt 요청 개수를 입력한다.
+		// @param [out] lstWork 작업대상 정보를 list형태로 전달
+		// @return true 처리할 data 가 존재하는 경우..
+		//         false 처리할 data 가 없는 경우
+		bool GetWork(unsigned int nCnt, std::list<CRetryData>& lstWork);
+		
+
+    private:
+                
+		// 복제대상 Content 정보를 관리하는 Queue 객체에 대한 포인터
+		CDataQueue<CSourceData> * m_pSourceQueue;
+        
+		// 복제 처리 관련 재시도 Content 정보를 관리하는 Queue 객체에 대한 포인터
+		CDataQueue<CRetryData> * m_pRetryQueue;
+
+		// Report log 처리 관련 객체
+		CReportLog m_reportLog;
+
+};
+
+#endif // __REPLICATE_QUEUE_CONTROL_H__

rcts/rc_rmcd/src/ReplicateSelect.cpp

@@ -0,0 +1,817 @@
+#include "ReplicateSelect.h"
+
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+
+#include "Logger.h"
+#include "Database.h"
+#include "ServiceConfig.h"
+#include "Util.h"
+
+
+// Replication 대상 조회시...
+// 현재 기준 얼마 이전에 업로드, 변경된 Content 를 대상으로 할 것인지에 대한 최대, 최소값
+// 기본적으로 conf 의 TARGET_SELECT_INTERVAL 설정값을 사용
+// 단위 : second
+#define MAX_TARGET_SELECT_INTERVAL		1800       // 30 분 이전 content 까지 대상으로 판단
+#define MIN_TARGET_SELECT_INTERVAL	      60       //  1 분 이전 content 까지 대상으로 판단
+
+
+// 프로세스 구동시 Replication 대상 선택 MAX, MIN 시간 ( hour 단위 )
+#define MIN_TARGET_SELECT_INTERVAL_ON_STARTING		1 
+
+// CHG 2014-07-16 huibong
+// 팀 회의 결과.. replication target select 주기는 
+// 기존의 복잡한 계산 로직 대신....고정값으로 sleep 처리토록 수정한다.
+// - 짧은 sleep 은 DB 부하만 발생시키고..  queue 처리 등을 고려했을 때 큰 의미가 없다고 판단.
+
+// Replicatin 처리시 매 Loop 마다 Sleep 시간 정보 정의 ( second 단위)
+#define DEFAULT_SLEEP_TIME  60
+
+// RCDB 접속 실패 또는 Query 실패 등의 상황 발생시 
+#define MAX_SLEEP_TIME      60
+
+
+// Query 문장 저장을 위한 Buffer 크기
+#define DEFAULT_QUERY_BUFFER_SIZE 1024
+
+////////////////////////////////////////////
+
+// 생성자
+CReplicateSelect::CReplicateSelect( CDataQueue<CSourceData> * pQueue )
+	: m_pSourceQueue( pQueue )
+	  , m_timeLastCheck(0)
+{
+	SetTargetSelectInterval( MAX_TARGET_SELECT_INTERVAL );
+	SetTargetSelectIntervalOnStarting( MIN_TARGET_SELECT_INTERVAL_ON_STARTING );
+	SetSleepTimeDefault();
+
+	m_threadHandle = 0;
+
+	// NEW 2014-06-16 신규 멤버 변수 초기화 코드 추가.
+	// Init() 에서 RCDB 접속 실패가 발생 가능하므로.. 구형 RCDB 형상을 사용토록 설정.
+	m_bServiceTableSeparate = false;
+}
+
+CReplicateSelect::~CReplicateSelect()
+{
+	// Thread 동작 정지 처리
+	// - 만약 Thread 가 이미 종료된 경우 m_threadHandle 이 다른 Thread Handle 일 수 있으므로 
+	//   업무 Flow 수정시 주의할 것
+	if( m_threadHandle != 0 )
+		pthread_cancel( m_threadHandle );	
+}
+
+// 초기화 작업 수행
+bool CReplicateSelect::Init()
+{
+	// 조회 정보를 저장할 Queue 포인터가 NULL 경우 오류 처리
+	if( m_pSourceQueue == NULL )
+	{
+		LOG( LERR, "replication queue is null");
+		return false;
+	}
+	
+	// Queue 정보 초기화 처리.
+	m_pSourceQueue->Init();
+
+	// 2014-06-13 huibong
+	// config 객체 변경 및 Skip Keyword 처리 관련 멤버 변수화에 따른 초기화 처리.
+	m_vecSipkWord = CServiceConfig::GetInstance()->GetSkipWord();
+
+	// RCDB 접속 정보 Load.
+	m_rcdbInfo.Load();
+
+	// RCDB 접속 처리를 위한 객체 생성
+	DataBase rcdb;
+	
+	// RCDB 접속 시도 및 접속 실패시
+	if( rcdb.PgOpenDB( m_rcdbInfo.m_strRcdbIp, m_rcdbInfo.m_nRcdbPort
+		             , m_rcdbInfo.m_strRcdbName, m_rcdbInfo.m_strRcdbAcct
+					 , m_rcdbInfo.m_strRcdbAcctPw ) == NULL )
+	{
+		LOG( LERR, "RCDB connection failed.");
+		return false;
+	}
+	else
+	{
+		// 접속 성공한 경우...
+		LOG( LINF, "RCDB connection test ok..." );
+				
+		// NEW 2014-06-13 huibong
+		// 서비스 table 분리된 신규 형상인지.. 구형 형상인지 체크하여
+		// m_bServiceTableSeparate 변수 설정 처리.
+		// 해당 변수 초기화는 생성자에서 1차로 수행함.
+		char szQuery[1024];
+		snprintf( szQuery, 1023,
+			      "SELECT * FROM pg_tables WHERE schemaname = 'public' AND tablename = 't_dav_resource' " );
+
+		rcdb.PgDoExec( szQuery );
+		if( rcdb.PgResult( DataBase::NOT_CLEAR ) < 0 )
+		{
+			// Query 수행 결과 오류 발생시...
+			// - pg_tables 가 존재하지 않을 경우 오류 발생 가능...
+			// - 이는 RCDB 가 아직 적절하게 구성되지 않았다는 의미이므로... Init()함수를 오류로 처리한다.
+			LOG( LERR, "RCDB t_dav_resource exist check failed.[%s][%s]", rcdb.GetErrorMessage().c_str(), szQuery );
+
+			rcdb.PgClear();
+			rcdb.PgCloseDB();
+
+			return false;
+		}
+		else
+		{
+			// Query 수행이 정상인 경우.
+			int  nResult = rcdb.GetNoTuples();
+			if( nResult > 0 )
+			{
+				// t_dav_resource 테이블이 존재하는 경우...
+				m_bServiceTableSeparate = false;
+				_LOG( LINF, "CReplicateSelect: t_dav_resource table exist.[Old RCDB Type]" );
+			}
+			else
+			{
+				// t_dav_resource 테이블이 존재하지 않는 서비스별 테이블 분리 형상인 경우.
+				m_bServiceTableSeparate = true;
+				_LOG( LINF, "CReplicateSelect: t_dav_resource table not exist.[New RCDB Type]" );
+			}
+		}
+		
+		// RCDB 조회 결과 set 를 clear 처리 후 RCDB 접속 해제.
+		rcdb.PgClear();
+		rcdb.PgCloseDB();
+
+		return true;
+	}
+}
+
+// Thread 를 생성하여 할당된 작업을 수행.
+bool CReplicateSelect::Start()
+{
+	int nRet = ::pthread_create( &m_threadHandle, NULL, CReplicateSelect::threadFunc, this );
+	if( nRet != 0 )
+	{
+		// Thread 생성 실패시
+		int errorNum = errno;
+		LOG( LERR, "Thread create failed.[%d][%s]", errorNum, strerror( errorNum ) );
+
+		return false;
+	}
+
+	return true;
+}
+
+bool CReplicateSelect::Start( unsigned int interval, unsigned int intervalOnStarting )
+{
+	SetTargetSelectInterval( interval );
+	SetTargetSelectIntervalOnStarting( intervalOnStarting );
+
+	return this->Start();
+}
+
+// Thread function
+void * CReplicateSelect::threadFunc( void * arg )
+{
+	CReplicateSelect* pObject = reinterpret_cast<CReplicateSelect *>( arg );
+	pthread_detach( pthread_self() );
+
+	while( 1 )
+	{
+		pthread_testcancel();
+		pObject->Execute();
+		pthread_testcancel();
+
+		sleep( pObject->m_timeSleep );       // 멤버변수에 설정된 시간만큼 Sleep 처리
+	}
+
+	// NEW 2014-06-13 huibong
+	// Thread 종료시 m_threadHandle 값을 초기화 처리.
+	// - 소멸자에서 잘못된 Thread 를 종료할 수 있기 때문.
+	pObject->m_threadHandle = 0;
+
+	// CHG 2014-06-13 huibong
+	// detach 된 Thread 에 대해 pthread_exit() 호출시
+	// 기준 할당 자원에 대한 해지 처리가 되지 않아 메모리 누수 발생 가능( FreeBSD ftsd 발생)
+	// 따라서 이를 해결하기 detach 된 thread 에 대해 pthread_exit() 호출 코드 제거.
+	//pthread_exit(NULL);
+	return NULL;
+}
+
+// loop 단위의 replication 대상 조회 작업 수행
+void CReplicateSelect::Execute()
+{
+	// DB 조회 처리 함수 호출
+	SelectFromDB();
+
+	// Logging
+	_LOG( LINF, "Replication target select complete. last check time[%lld], sleep[%u] sec", m_timeLastCheck, m_timeSleep );
+}
+
+
+// RCDB 로 부터 Replication 대상 Content 를 조회한 후...
+// 해당 정보를 Queue 상에 저장한다.
+bool CReplicateSelect::SelectFromDB()
+{
+	// 1. 현재 시간정보를 구한다.( micro-second 단위)
+	long long timeNow = longtime_now(); 
+	if (timeNow < 0)
+	{
+		LOG( LERR, "longtime_now function error [%lld]", timeNow);
+		return false;
+	}
+
+	// 2. RCDB 와 연결 처리.
+	DataBase rcdb;	
+	if( rcdb.PgOpenDB( m_rcdbInfo.m_strRcdbIp, m_rcdbInfo.m_nRcdbPort
+		, m_rcdbInfo.m_strRcdbName, m_rcdbInfo.m_strRcdbAcct
+		, m_rcdbInfo.m_strRcdbAcctPw ) == NULL )
+	{
+		LOG( LERR, "RCDB connection failed." );
+
+		// DB 접속이 실패했으므로 Sleep Time 을 최대로 설정한다.		
+		SetSleepTimeMax();
+		return false;		
+	}
+
+	// Query 문장 저장을 위한 버퍼 생성
+	char szQuery[DEFAULT_QUERY_BUFFER_SIZE];
+	// Query 수행 결과값 저장을 위한 변수..
+	// - 최종 조회된 Replication 대상 content count 정보를 저장.
+	int nResult = 0;
+
+	// 3. t_sms_sp_svc_product 에서 각 고객사별 Replication count 정보를 가져온다.		
+	snprintf(szQuery, DEFAULT_QUERY_BUFFER_SIZE - 1,
+			"SELECT sp_svc_tran_id, replication_count "
+			"FROM t_sms_sp_svc_product "
+			"WHERE replication_count > 0 "
+			"ORDER BY sp_svc_tran_id desc "
+			);
+
+	// Query 실행 
+	rcdb.PgDoExec(szQuery);
+	nResult = rcdb.PgResult( DataBase::NOT_CLEAR );	
+	if( nResult < 0 )
+	{
+		// RCDB t_sms_sp_svc_product 에 replication_count 컬럼이 존재하지 않는 경우
+		// - Replication 처리를 당장 수행할 필요가 없으므로 루프 대기처리후 다음에 다시 조회처리.
+		LOG( LERR, "RCDB t_sms_sp_svc_product table replication_count column not exist.[%s][%s]"
+			, rcdb.GetErrorMessage().c_str(), szQuery );
+		
+		rcdb.PgClear();
+		rcdb.PgCloseDB();
+
+		// 마지막 실행시간을 현재시간으로 변경처리한 후 정상으로 반환처리한다.
+		// 또한 Sleep Time 역시 최대로 변경처리한다.
+		m_timeLastCheck = timeNow;		
+		SetSleepTimeMax();
+		return true;
+	}
+
+	// 조회된 각 고객사별 replication 정보 확인
+	nResult = rcdb.GetNoTuples();
+	if( nResult <= 0 )
+	{
+		// Replication 을 수행할 고객사가 존재하지 않는 경우
+		_LOG( LINF, "ReplicateTargetSelector: service not found that content replicate.[%d]"
+			, nResult );
+		
+		rcdb.PgClear();
+		rcdb.PgCloseDB();
+		
+		// 마지막 실행시간을 현재시간으로 변경처리한 후 정상으로 반환처리한다.
+		// 또한 Sleep Time 역시 최대로 변경처리한다.
+		m_timeLastCheck = timeNow;		
+		SetSleepTimeMax();
+		return true;
+	}
+
+	// Replication 을 수행할 고객사가 존재하는 경우 멤버변수에 저장
+	m_listCustomer.clear();
+	for( int i =0 ; i< nResult; i++ )
+	{
+		// map 객체이므로.. key - value 형식으로 저장 처리.
+		m_listCustomer[ rcdb.GetValue(i,0) ] = atoi( rcdb.GetValue(i,1));
+	}
+
+	// Query Resultset Clear.
+	rcdb.PgClear();
+
+	
+	// 4. Replication 대상 파일을 조회한다.
+	//    - 구형 RCDB 형상(m_bServiceTableSeparate == false) : t_dav_resouce 테이블에서 조회
+	//    - 신형 RCDB 형상(m_bServiceTableSeparate == true ) : t_meta_tranid 테이블에서 조회
+		
+	// 조회 시작시간은 이전에 저장된 m_timeLastCheck 에서 지정된 제외시간 빼고
+	// 조회 종료시간은 현재시간에서 지정된 제외시간만큼 뺀다.	
+	long long timeSearchStart;
+	long long timeSearchEnd;
+	
+	// 만약 최초 동작인 경우
+	if( m_timeLastCheck == 0 )
+	{
+		// 현재시간으로부터 지정된 시간만큼 뺀 시간을 조회시작시간으로 설정.
+		timeSearchStart = ( timeNow - GetTargetSelectIntervalOnStarting() );
+	}
+	else
+	{
+		// 이전 조회처리 시간에서 지정된 제외시간 만큼 뺀 시간을 시작시간으로 설정.		
+		timeSearchStart = ( m_timeLastCheck - GetTargetSelectInterval() );
+	}
+
+	// 조회 종료시간은 현재시간에서 지정된 제외시간만큼 뺀다.	
+	timeSearchEnd = ( timeNow - GetTargetSelectInterval() );
+
+
+	// NEW 2014-07-16 huibong
+	// 시간 동기화 관련 방어 코드 추가
+	// - 잘못된 시간 동기화로 인해 조회 종료시간 <= 조회 시작시간 인 경우...
+	// - Replication 대상 조회가 안돼 아래 Flow 의미가 없어지므로...  방어 코드 추가한다.
+	if( timeSearchEnd <= timeSearchStart )
+	{
+		// 에러 정보 로깅 후..
+		// RCDB 연결 해제 처리
+		// 마지막 Check Time 은 
+		// - 시간 동기화로 오류(실제 시간보다 빨라) 인해 복제가 발생하지 않았을 수 있으므로...
+		// - 초기 기동 Flow 가 동작하도록 0 으로 설정 처리한다.
+		// Sleep Time 최대로 변경처리한다.
+		LOG( LERR, "Search end time[%lld] lower than start time[%lld]. check ntpdate."
+			, timeSearchEnd, timeSearchStart );			
+
+		rcdb.PgClear();
+		rcdb.PgCloseDB();
+
+		// 초기 기동 Flow 가 동작하도록 설정.
+		m_timeLastCheck = 0;
+		// Sleep time 은 최대로
+		SetSleepTimeMax();
+
+		return false;
+	}
+
+	/////////////////////////////////////////////////////////////////////////////////
+	// NEW 2014-06-16 huibong
+	// - RCDB 신규 형상 재설계에 따라...Meta 정보가 서비스별 Table 단위로 분리됨.
+	// - 이에 기존 버전과 하위 호환성을 위해 t_dav_resource 테이블 존재 유무에 따라..
+	// - replication 대상 content 조회 방식을 변경한다.
+
+	// 구형 RCDB 형상인 경우.
+	if( m_bServiceTableSeparate == false )
+	{
+		// t_dav_resource 에서 최신 Content 목록 조회 후
+		// replication 대상 서비스인지 검사 후.
+		// Queue 에 저장 처리.
+		
+		// Replication 대상 선택을 위한 Query 생성
+		// CHG 2014-06-19 huibong
+		// - 노경민 과장 요청에 의해 서브 query 상에서 uri 에 대한 DISTINCT 구문 제외
+
+		// CHG 2015-03-26 huibong
+		// - Cache 가 먼저 생성된 경우 cache 가 복제 대상으로 선택되는 버그 발견됨 (#21903)
+		// - 이를 해결하기 위해 AND is_cache   = 'N' 조건절 추가함.
+
+		snprintf( szQuery, DEFAULT_QUERY_BUFFER_SIZE - 1,
+			"SELECT filename_hash, host_name, get_content_length, sp_svc_tran_id, uri "
+			"FROM t_dav_resource "
+			"WHERE uri IN "
+			"   ( "
+			"       SELECT uri FROM t_dav_resource  "
+			"       WHERE   get_lastmodified >= %lld "
+			"           AND get_lastmodified < %lld "
+			"           AND deleted_yn  = 'N' "
+			"           AND is_cache !='Y' "  // 캐시된 장비는 대상 선택에 영향을 미치면 안된다. 일시적인 복제증가이기 때문에 나중에 사라져버리기 때문이다.
+			"       GROUP BY uri "
+			"       HAVING COUNT(*) = 1 "     // including is_cache ='N|R' resut=1
+			"   ) "
+			"   AND deleted_yn = 'N' "        // 삭제된 content 는 제외.
+			"   AND is_cache   = 'N' "        // 2015-03-26 #21903 cache 가 먼저 생성된 경우.. 제외 처리
+			"   AND resource_type = 0 "       // 파일만.(0:file, 1:directory)
+			"   AND get_content_length != 0 " // 업로드 시작시 content_length=0 으로 insert된다. 즉, 0인것은 업로드중으로 간주한다.
+			"   ORDER BY uri, get_lastmodified desc; "
+			, timeSearchStart, timeSearchEnd			
+			);
+
+		_LOG( LDBG, "CReplicateSelect: select t_dav_resource, time[%lld]~[%lld]", timeSearchStart, timeSearchEnd );
+
+		// Query 실행 및 결과 확인
+		rcdb.PgDoExec( szQuery );
+		nResult = rcdb.PgResult( DataBase::NOT_CLEAR );
+		if( nResult < 0 )
+		{
+			// RCDB t_dav_resource 테이블 조회 실패시
+			// Replication 처리를 당장 수행할 필요가 없으므로 
+			// 루프 대기처리후 다음에 다시 조회처리.		
+			LOG( LERR, "RCDB t_dav_resource replication content select failed.[%s][%s]"
+				,  rcdb.GetErrorMessage().c_str(), szQuery );
+
+			rcdb.PgClear();
+			rcdb.PgCloseDB();
+
+			// 마지막 실행시간은 이전 값을 사용하도록 설정하지 않는다.
+			// 또한 Sleep Time 역시 최대로 변경처리한다.
+			SetSleepTimeMax();
+			return false;
+		}
+
+		// 결과 Row 수 확인
+		nResult = rcdb.GetNoTuples();
+		if( nResult < 0 )
+		{
+			// 오류 발생시
+			LOG( LERR, "RCDB t_dav_resource GetNoTuples() error[%s][%s]"
+				, rcdb.GetErrorMessage().c_str(), szQuery );
+
+			rcdb.PgClear();
+			rcdb.PgCloseDB();			
+
+			// 마지막 실행시간은 이전 값을 사용하도록 설정하지 않는다.
+			// 또한 Sleep Time 역시 최대로 변경처리한다.
+			SetSleepTimeMax();
+			return false;
+		}
+		else if( nResult == 0 )
+		{
+			// 조회 결과가 존재하지 않는 경우
+			_LOG( LINF, "Replicaiton target content not exist. time[%lld]~[%lld]", timeSearchStart, timeSearchEnd );
+			
+			rcdb.PgClear();
+			rcdb.PgCloseDB();
+			
+			// 마지막 실행시간을 현재시간으로 변경처리한 후 정상으로 반환처리한다.
+			// 또한 Sleep Time 역시 최대로 변경처리한다.
+			m_timeLastCheck = timeNow;			
+			SetSleepTimeMax();
+			return true;
+		}
+
+		// 조회 결과가 존재하는 경우 조회된 결과를 Queue 에 저장	
+		map< std::string, int >::iterator it;
+		CSourceData resultData;
+		int iPushCount = 0;
+		std::string strTemp;
+		for( int k = 0; k < nResult; k++ )
+		{
+			// 조회된 서비스 정보가 고객사 Replication List 상에 존재하는지 검사한다.
+			strTemp = rcdb.GetValue( k, 3 );
+			it = m_listCustomer.find( strTemp );
+
+			// 해당 정보를 찾은 경우
+			if( it != m_listCustomer.end() )
+			{
+				// 2012.09.24 : dadmain
+				// 복제본 생성되지 않을 문자열이 포함되어 있는지 체크한다. 
+				string uri = rcdb.GetValue( k, 4 );
+				if( HasSkipKeyWord( uri ) == false )
+				{
+					resultData.m_szURI             = uri;
+					resultData.m_szFileNameHash    = rcdb.GetValue( k, 0 );
+					resultData.m_szOriginHostName  = rcdb.GetValue( k, 1 );
+					resultData.m_nContentLength    = atoll( rcdb.GetValue( k, 2 ) );
+					resultData.m_nReplicationCount = it->second;					
+
+					// 2014-06-16 huibong
+					// 신규 RCDB 형상 지원을 위해 service sequecn (구 tran_id)정보 추가 처리.
+					resultData.m_szServiceSeq      = strTemp;
+					
+					// Queue 에 저장 처리.
+					PushDataToSourceQueue( resultData );					
+					iPushCount++;
+				}
+				else
+				{
+					// skip	
+					_LOG( LWAR, "Replication selected. but URI has SIKP_KEYWROD.[%s]", uri.c_str() );
+				}
+			}
+		}
+		_LOG( LINF, "Replication target selected. total[%d], queue insert[%d]", nResult, iPushCount );		
+	}
+	else
+	{
+		// 서비스별 meta 테이블인 분리된 신형 RCDB 형상인 경우...
+		// - 이미 조회된 replication 대상 고객사 table 에서만 조회 처리 후
+		// - queue 에 저장 처리.
+		map< std::string, int >::iterator it;
+		std::string strServiceName;
+		
+		// nResult 값에 따라... sleep time 이 조절되므로....
+		// 전체 조회 건수를 nResult 에 저장 처리해야 한다.
+		nResult = 0;
+
+		// 각 Query 수행 결과 저장을 위한 임시 변수. (nResult 변수 대치목적)
+		int dbResult;
+		CSourceData resultData;
+		int iPushCount = 0;
+
+		// Replication 대상 서비스별 Content 조회
+		for( it = m_listCustomer.begin(); it != m_listCustomer.end(); ++it )
+		{
+			strServiceName    = it->first;			
+
+			// Replication 대상 선택을 위한 Query 생성
+			// CHG 2014-06-19 huibong
+			// - 노경민 과장 요청에 의해 서브 query 상에서 uri 에 대한 DISTINCT 구문 제외
+
+			// CHG 2015-03-26 huibong
+			// - Cache 가 먼저 생성된 경우 cache 가 복제 대상으로 선택되는 버그 발견됨 (#21903)
+			// - 이를 해결하기 위해 AND is_cache   = 'N' 조건절 추가함.
+
+			snprintf( szQuery, DEFAULT_QUERY_BUFFER_SIZE - 1,
+				"SELECT filename_hash, host_name, get_content_length, sp_svc_tran_id, uri "
+				"FROM t_meta_%s "
+				"WHERE uri IN "
+				"   ( "
+				"       SELECT uri FROM t_meta_%s  "
+				"       WHERE   get_lastmodified >= %lld "
+				"           AND get_lastmodified < %lld "
+				"           AND deleted_yn  = 'N' "
+				"           AND is_cache !='Y' "  // 캐시된 장비는 대상 선택에 영향을 미치면 안된다. 일시적인 복제증가이기 때문에 나중에 사라져버리기 때문이다.
+				"       GROUP BY uri "
+				"       HAVING COUNT(*) = 1 "     // including is_cache ='N|R' resut=1
+				"   ) "
+				"   AND deleted_yn = 'N' "        // 삭제된 content 는 제외.
+				"   AND is_cache   = 'N' "        // 2015-03-26 #21903 cache 가 먼저 생성된 경우.. 제외 처리
+				"   AND resource_type = 0 "       // 파일만.(0:file, 1:directory)
+				"   AND get_content_length != 0 " // 업로드 시작시 content_length=0 으로 insert된다. 즉, 0인것은 업로드중으로 간주한다.
+				"   ORDER BY uri, get_lastmodified desc; "
+				, strServiceName.c_str(), strServiceName.c_str()
+				, timeSearchStart, timeSearchEnd
+				);
+			
+			_LOG( LDBG, "CReplicateSelect: select t_meta_%s, time[%lld]~[%lld]", strServiceName.c_str(), timeSearchStart, timeSearchEnd );
+
+			// Query 실행 및 결과 확인
+			rcdb.PgDoExec( szQuery );
+			dbResult = rcdb.PgResult( DataBase::NOT_CLEAR );
+			if( dbResult < 0 )
+			{
+				// RCDB t_meta_xxx 테이블 조회 실패시
+				// 해당 서비스에 대해서는 Replication 처리를 당장 수행할 필요가 없다.				
+				LOG( LERR, "RCDB t_meta_%s replication content select failed.[%s][%s]"
+					, strServiceName.c_str(), rcdb.GetErrorMessage().c_str(), szQuery );
+
+				rcdb.PgClear();
+
+				// loop 계속 수행.
+				continue;
+			}
+
+			// 결과 Row 수 확인 
+			dbResult = rcdb.GetNoTuples();
+			if( dbResult < 0 )
+			{
+				// 오류 발생시
+				LOG( LERR, "RCDB t_meta_%s GetNoTuples() error[%s][%s]"
+					, strServiceName.c_str(), rcdb.GetErrorMessage().c_str(), szQuery );
+
+				// loop 계속 수행.
+				rcdb.PgClear();
+				continue;
+			}
+			else if( dbResult == 0 )
+			{
+				// 조회 결과가 존재하지 않는 경우
+				//_LOG( LDBG, "Replication target content not exist. service[%s], time[%lld]~[%lld]"
+				//	, strServiceName.c_str(), timeSearchStart, timeSearchEnd );
+
+				// loop 계속 수행.
+				rcdb.PgClear();
+				continue;
+			}
+						
+			// 조회 결과가 존재하는 경우 조회된 결과를 Queue 에 저장
+			iPushCount = 0;
+			for( int k = 0; k < dbResult; k++ )
+			{
+				// Skip keyword 에 포함되어 있는지 확인
+				string uri = rcdb.GetValue( k, 4 );
+				if( HasSkipKeyWord( uri ) == false )
+				{
+					resultData.m_szURI             = uri;
+					resultData.m_szFileNameHash    = rcdb.GetValue( k, 0 );
+					resultData.m_szOriginHostName  = rcdb.GetValue( k, 1 );
+					resultData.m_nContentLength    = atoll( rcdb.GetValue( k, 2 ) );
+					resultData.m_nReplicationCount = it->second;
+
+					// 2014-06-16 huibong
+					// 신규 RCDB 형상 지원을 위해 service sequecn (구 tran_id)정보 추가 처리.
+					resultData.m_szServiceSeq = strServiceName;
+
+					// Queue 에 저장 처리.
+					PushDataToSourceQueue( resultData );
+					iPushCount++;
+				}
+				else
+				{
+					// skip	
+					_LOG( LWAR, "Replication selected. but URI has SIKP_KEYWROD.[%s][%s]"
+						, strServiceName.c_str(), uri.c_str() );
+				}
+			}
+
+			// 다음 Query loop 조회를 위해 RCDB 조회 결과 set 을 clear 처리
+			rcdb.PgClear();
+
+			// 로깅
+			_LOG( LINF, "Replication target selected. service[%s], total[%d], queue insert[%d]"
+				, strServiceName.c_str(), dbResult, iPushCount );
+			
+			// 조회 결과를 합산 처리.
+			nResult += dbResult;
+		}
+	}
+
+	//////////////////////////////////////////////////
+
+	// RCDB 관련 정리 처리.
+	rcdb.PgClear();
+	rcdb.PgCloseDB();
+
+	// 마지막 조회시간을 현재시간으로 설정한다.
+	m_timeLastCheck = timeNow;
+	
+	// Sleep Time 설정.
+	SetSleepTimeDefault();
+	
+	return true;
+}
+
+
+// loop 간 sleep time 을 MAX 값으로 설정.
+void CReplicateSelect::SetSleepTimeMax()
+{
+	m_timeSleep = MAX_SLEEP_TIME;
+	return;
+}
+
+// loop 간 sleep time 을 default 값으로 설정.
+void CReplicateSelect::SetSleepTimeDefault()
+{
+	m_timeSleep = DEFAULT_SLEEP_TIME;
+	return;
+}
+
+
+// replication 대상 선택시 시간 term 설정
+void CReplicateSelect::SetTargetSelectInterval( unsigned int sec )
+{
+	if( sec > MAX_TARGET_SELECT_INTERVAL )
+	{
+		sec = MAX_TARGET_SELECT_INTERVAL;
+		LOG( LWAR, "conf[TARGET_SELECT_INTERVAL] value[%u] too high. use default[%d]", sec, MAX_TARGET_SELECT_INTERVAL );
+	}
+	else if( sec < MIN_TARGET_SELECT_INTERVAL )
+	{
+		sec = MIN_TARGET_SELECT_INTERVAL;
+		LOG( LWAR, "conf[TARGET_SELECT_INTERVAL] value[%u] too low. use default[%d]", sec, MIN_TARGET_SELECT_INTERVAL );
+	}
+
+	// BUG 2010-12-10 hjjang
+	// int 형의 곱셈은 int 결과로 나오며..  이때 range overflow 가 발생하므로 
+	// 아래와 같이 수정처리함.
+	// sec * 1000000 :  micro-second 단위로 변환.
+	m_nTargetSelectInterval = (long long)( sec * 1000000LL );
+
+}
+
+// 프로세스 구동시의 replication 대상 선택 시간 term 설정
+void CReplicateSelect::SetTargetSelectIntervalOnStarting( unsigned int hour )
+{
+	if( hour < MIN_TARGET_SELECT_INTERVAL_ON_STARTING )
+	{
+		hour = MIN_TARGET_SELECT_INTERVAL_ON_STARTING;
+
+		LOG( LWAR, "conf[TARGET_SELECT_INTERVAL_ON_STARTING] value[%u] too low. use default[%d]"
+			, hour, MIN_TARGET_SELECT_INTERVAL_ON_STARTING );
+	}
+
+	// BUG 2010-12-09 huibong
+	// int 형의 곱셈은 int 결과로 나오며..  이때 range overflow 가 발생하므로 
+	// 아래와 같이 수정처리함.
+	// hour * 3600 * 1000000 : micro-second 단위로 변환.
+	m_nTargetSelectIntervalOnStarting = (long long)( hour * 3600LL * 1000000LL );
+}
+
+// micro second 단위로 설정된 replication 대상 선택 시간 term 을 반환
+long long CReplicateSelect::GetTargetSelectInterval()
+{
+	return m_nTargetSelectInterval;
+}
+
+// micro second 단위로 설정된 프로세스 구동시의 replication 대상 선택 시간 term 을 반환
+long long CReplicateSelect::GetTargetSelectIntervalOnStarting()
+{
+	return m_nTargetSelectIntervalOnStarting;
+}
+
+// 전달받은 data 를 멤버변수인 m_pSourceQueue 에 push 처리한다.
+void CReplicateSelect::PushDataToSourceQueue( CSourceData& data )
+{
+	int errorCount = 0;
+	while( m_pSourceQueue->Push( data ) == false )
+	{
+		if( ++errorCount == 3 )
+		{
+			LOG( LWAR, "data push into queue failed. retry. filenamehash[%s]", data.m_szFileNameHash.c_str() );
+			errorCount = 0;
+		}
+
+		sleep( 1 ); // 1 초 마다 재시도
+	}
+
+	return;
+}
+
+
+/// 2012.09.24 : dadamin
+/// @brief 해당 uri에 skip keyword가 포함되어있는지 체크함
+/// @param [in] uri : 복제 대상 URI(복제 대상 full 파일명)
+/// @return ture 시 해당 uri에 skip keyword를 포함
+bool CReplicateSelect::HasSkipKeyWord( const std::string & uri )
+{
+	if( m_vecSipkWord.size() == 0 )
+		return false;
+
+	bool r = false;
+	for( int i = 0; i< (int)m_vecSipkWord.size(); ++i )
+	{
+		string k = m_vecSipkWord[i];
+
+		if( k.size() )
+		{
+			std::vector<string> v;
+			StringSplit( k, "|", v, false );
+
+			std::string::size_type pos;
+
+			pos = uri.find( v[1] );
+
+			if( pos != std::string::npos )
+			{
+				switch( v[0][0] )
+				{
+				case 'h':
+				{
+					// uri 형식이 /tran_id/path 이기 때문에 
+					// head 위치는 2번째 '/' 위치와 동일핟.
+					std::string::size_type towpos = uri.find( "/", 1 );
+
+					if( towpos == pos )
+					{
+						r = true;
+						LOG( LDBG, "Check Skip keyword HEAD- %s:%s", uri.c_str(), v[1].c_str() );
+						break;
+					}
+				}
+					break;
+				case 'm':
+					if( pos > 0 && uri.size() > pos + v[1].size() )
+					{
+						r = true;
+						LOG( LDBG, "Check Skip keyword MIDDLE - %s:%s", uri.c_str(), v[1].c_str() );
+						break;
+					}
+					break;
+				case 't':
+					if( pos > 0 && uri.size() == pos + v[1].size() )
+					{
+						r = true;
+						LOG( LDBG, "Check Skip keyword TAIL - %s:%s", uri.c_str(), v[1].c_str() );
+						break;
+					}
+					break;
+				default:
+					r = false;
+					LOG( LWAR, "unknown find type. %s", uri.c_str() );
+					break;
+				}
+				break;
+			}
+		}
+	}
+	return r;
+}
+
+void CReplicateSelect::StringSplit( std::string str, std::string delim, std::vector<std::string> &results, bool bUseEmpty /*= false*/ )
+{
+	const std::string strEmpty( "" );
+	std::string::size_type cutAt;
+
+	while( ( cutAt = str.find_first_of( delim ) ) != str.npos )
+	{
+		if( cutAt > 0 )
+		{
+			results.push_back( str.substr( 0, cutAt ) );
+		}
+		else
+		{
+			if( bUseEmpty && cutAt == 0 )
+				results.push_back( strEmpty );
+		}
+		str = str.substr( cutAt + 1 );
+	}
+	if( str.length() > 0 )
+	{
+		results.push_back( str );
+	}
+}

rcts/rc_rmcd/src/ReplicateSelect.h

@@ -0,0 +1,135 @@
+/***************************************************************************
+                Replicate 대상 content 정보 조회 class
+                -----------------------------------------
+    begin      : 2010/03/11
+    copyright  : (C) 2010 Solbox Inc.
+    author     : storage dev team
+    email      : storage.sd@solbox.com
+    version    : 3.3
+
+    CopyRight(C) 2010 Solbox Inc. All Rights reserved.
+    Redistribution and use in source and binary forms, with or with out
+    modification, are not permitted in outside of Solbox Inc.
+***************************************************************************/
+
+#ifndef __REPLICATE_SELECT_H__ 
+#define __REPLICATE_SELECT_H__
+
+#include <pthread.h>
+#include <map>
+
+#include "ReplicationData.h"
+#include "RcdbInfo.h"
+#include "DataQueue.hpp"
+
+// CReplicateSelect
+// 복제 대상 content 를 RCDB 로 부터 조회하여... Queue 에 저장 처리를 수행.
+// 내부적으로 Thread 를 사용하여 주기적으로 RCDB 를 연결 후 조회 처리.
+class CReplicateSelect
+{
+
+	public:
+		// 생성자
+		// @param [in] pCSsourceData 조회된 Content 정보를 저장할 Queue 객체 포인트
+		CReplicateSelect( CDataQueue<CSourceData> * pQueue );
+
+		// 소멸자
+		~CReplicateSelect();
+
+		// 초기화 작업 및 DB 접속 정보를 이용하여 RCDB Test 접속을 수행함.
+		bool Init();
+		
+		// Thread를 생성하고, 이를 시작한다.
+		bool Start();
+
+		// 2010년 12월 6일 장희준 추가
+		// Thread를 생성하고, 이를 시작한다.
+		// 인자로 Replication 대상 선택을 위한 초단위의 시간 설정값을 받는다.
+		bool Start( unsigned int interval, unsigned int intervalOnStarting );
+
+			
+	private:
+		
+		// Replication 대상 File 정보를 저장하기 위한 Queue 객체에 대한 Pointer, Not NULL
+		CDataQueue<CSourceData> * m_pSourceQueue;
+	
+		// 내부 Thread 에 대한 ID
+		pthread_t m_threadHandle;
+
+		// RCDB 접속 정보를 저장할 변수.
+		CRcdbInfo m_rcdbInfo;
+
+		// 마지막 DB 조회 시간을 저장하기 위한 변수 ( micro-second 단위 )
+		long long m_timeLastCheck;
+
+		// Thread Loop 마다 Sleep Time 정보를 저장하기 위한 변수
+		unsigned int m_timeSleep;	
+
+		// 각 고객사별 Replicatin Count 정보를 저장하기 위한 변수
+		// t_sms_sp_svc_product 테이블에 저장된 고객 tran_id 별 Repliation count 정보를 저장한다.
+		std::map< std::string, int > m_listCustomer;
+
+		// Replication 대상 선택 주기. 단위 :  microsec
+		long long m_nTargetSelectInterval;
+
+		// 프로세스 구동시의 replication 대상 선택 주기. 단위 : microsec 
+		long long m_nTargetSelectIntervalOnStarting;
+
+		// New 2014-06-13 huibong
+		// uri skip 처리 관련 설정 정보 저장을 위한 vector 객체 생성.
+		// 모든 content 마다 검사하는 정보이므로 처리 속도 향상을 위해 멤버변수화 처리함.
+		std::vector<std::string> m_vecSipkWord;
+
+		// New 2014-06-13 huibong
+		// RCDB 형상변경에 따라 서비스별 Table 분리 여부 판단 flag
+		// TODO: 향후 신규 RCDB 형상 적용 완료 후 본 항목 제거 필요.
+		// - false : 기존 t_dav_resource 테이블 사용.
+		// - ture  : 신규 RCDB 형상 (서비스별 meta table 분리) 사용.
+		bool m_bServiceTableSeparate;
+
+		
+
+	private:
+
+		// 스레드 함수
+		static void* threadFunc( void* arg );
+
+		// loop 단위의 replication 대상 조회 작업 수행
+		void Execute();
+
+		// RCDB 로 부터 Replication 대상 content 조회		
+		bool SelectFromDB();
+	
+		// replication 대상 선택시 시간 term 설정
+		void SetTargetSelectInterval( unsigned int sec );
+				
+		// 프로세스 구동시의 replication 대상 선택 시간 term 설정		
+		void SetTargetSelectIntervalOnStarting( unsigned int hour );
+		
+		// micro second 단위로 설정된 replication 대상 선택 시간 term 을 반환
+		long long GetTargetSelectInterval();
+				
+		// micro second 단위로 설정된 프로세스 구동시의 replication 대상 선택 시간 term 을 반환
+		long long GetTargetSelectIntervalOnStarting();
+
+		// 전달받은 data 를 멤버변수인 m_pSourceQueue 에 push 처리한다.
+		void PushDataToSourceQueue( CSourceData& data );
+
+		/// 2012.09.24 : dadamin
+		/// @brief 해당 uri에 skip keyword가 포함되어있는지 체크함
+		/// @param [in] uri : 복제 대상 URI(복제 대상 full 파일명)
+		/// @return ture 시 해당 uri에 skip keyword를 포함
+		bool HasSkipKeyWord( const std::string & uri );
+		void StringSplit( std::string str, std::string delim, std::vector<std::string> &results, bool bUseEmpty );
+		
+
+		// loop 간 sleep time 을 MAX 값으로 설정.
+		void SetSleepTimeMax();
+
+		// loop 간 sleep time 을 default 값으로 설정.
+		void SetSleepTimeDefault();
+
+		
+};
+
+#endif // __REPLICATE_SELECT_H__

rcts/rc_rmcd/src/ReplicateThread.cpp

@@ -0,0 +1,397 @@
+#include "ReplicateThread.h"
+
+#include <errno.h>
+#include <time.h>
+#include <string.h>
+
+#include "Logger.h"
+#include "FtsdSocketControl.h"
+#include "ServiceConfig.h"
+#include "ReportLog.h"
+
+
+// ftsd 로 부터 처리 결과 수신을 위한 Total 대기 시간 정의 ( sec )
+#define FHS_RESPONSE_TOTAL_TIMEOUT  3600   // ( sec, 1 hour )
+
+// ftsd 로 부터 응답 수신 확인을 위한 socket read timeout (sec)
+#define FHS_RESPONSE_CHECK_TIMEOUT  3      // 3 sec
+
+////////////////////////////////////////////
+
+// 생성자
+CReplicateThread::CReplicateThread( CProcessStatus* const pProcessStatus
+		, CDataQueue<CRetryData>* const pQueueRetry
+		, CDataQueue<CCompleteData>* const pQueueComplete
+		, CRetryData& dataJob
+		, std::vector<std::string>& vecTargetFHS )
+	: m_pProcessStatus( pProcessStatus )
+		, m_pRetryQueue( pQueueRetry )
+		, m_pCompleteQueue( pQueueComplete )
+		, m_dataJob( dataJob )
+		, m_vecTargetFHS( vecTargetFHS )
+{
+	// 멤버 변수 초기화
+	m_threadHandle = 0;
+}
+
+// 소멸자
+CReplicateThread::~CReplicateThread()
+{
+	// Thread 동작 정지 처리
+	// - 만약 Thread 가 이미 종료된 경우 m_threadHandle 이 다른 Thread Handle 일 수 있으므로 
+	//   업무 Flow 수정시 주의할 것
+	if( m_threadHandle != 0 )
+		pthread_cancel( m_threadHandle );
+}
+
+// 실제 Replication 생성 작업을 수행
+bool CReplicateThread::Start()
+{
+	int nRet = ::pthread_create( &m_threadHandle, NULL, CReplicateThread::threadFunc, this );
+	if( nRet != 0 )
+	{
+		// Thread 생성 실패시
+		int errorNum = errno;
+		LOG( LERR, "Thread create failed.[%d][%s]", errorNum, strerror( errorNum ) );
+
+		return false;
+	}
+		
+	return true;
+}
+
+// 스레드 함수
+void* CReplicateThread::threadFunc( void* arg )
+{
+	CReplicateThread* pObject = reinterpret_cast<CReplicateThread *>( arg );
+	pthread_detach( pthread_self() );
+
+	pthread_testcancel();
+	// Thread 동작시 Thread Count 1 증가 처리
+	pObject->m_pProcessStatus->AddReplicationCount();
+
+	// 실제 작업 수행.
+	pObject->Execute();
+
+	// Thread 동작 완료시 Thread Count 1 감소 처리
+	pObject->m_pProcessStatus->SubtractReplicationCount();
+	pthread_testcancel();
+
+
+	// NEW 2014-06-25 huibong
+	// Thread 종료시 m_threadHandle 값을 초기화 처리.
+	// - 소멸자에서 잘못된 Thread 를 종료할 수 있기 때문.
+	pObject->m_threadHandle = 0;
+
+	// 객체 자동 delete 처리.
+	delete pObject;	
+	return NULL;
+}
+
+// 실제 Replication 생성 작업을 수행
+void CReplicateThread::Execute()
+{
+	// 1. FHS 의 ftsd 와 통신 처리를 담당할 socket control 객체 생성.
+	CFtsdSocketControl fhs;
+
+	// 2. 원본 Content를 가진 FHS ftsd 에 접속 수행.
+	bool bResult = fhs.ConnectTarget( m_dataJob.m_OriginData.m_szOriginHostName, CServiceConfig::GetInstance()->GetFhsTransferDaemonPort());
+	if( bResult == false )
+	{
+		// 원본 FHS 와 접속 실패시
+		// - 로깅 후 Retry Queue 에 저장 처리
+		_LOG( LERR, "CReplicateThread: source fhs[%s] connect fail.[%s]"
+			, m_dataJob.m_OriginData.m_szOriginHostName.c_str()
+			, m_dataJob.m_OriginData.m_szURI.c_str() );
+
+		DoFailProcess();
+		return;
+	}
+
+	// 3. 연결된 원본 FHS 로 replication 생성 요청을 전달
+	bResult = fhs.SendFileReplicationRequest( m_dataJob.m_OriginData.m_szFileNameHash
+						, m_dataJob.m_OriginData.m_nContentLength
+						, CServiceConfig::GetInstance()->GetHashCheckLevel()
+						, true
+						, m_vecTargetFHS );
+	if( bResult == false )
+	{
+		// replication 요청 전달 실패시
+		// - 로깅 후 Retry Queue 에 저장 처리
+		_LOG( LERR, "CReplicateThread: replication request send fail.[%s][%s]"
+			, m_dataJob.m_OriginData.m_szOriginHostName.c_str()
+			, m_dataJob.m_OriginData.m_szURI.c_str() );
+
+		DoFailProcess();
+		return;
+	}
+
+	// 4. FHS 로 부터 처리 결과를 수신할때 까지 대기
+	//    - 이상 상황 발생시 무한 대기 가능성이 존재하므로.. 
+	//      미리 정의된 FHS_RESPONSE_TOTAL_TIMEOUT 까지만 대기하도록 한다.
+
+	// response timeout 처리를 위한 변수
+	time_t timeStart;
+	time_t timeNow;
+
+	// 응답 결과를 저장하기 위한 변수
+	int nResult;
+	bool bSuccess = false;
+	std::string szErrorMessage;
+	
+	// 대기 시작 전 현재시간을 구한다.
+	timeStart = time( &timeStart );
+		
+	// FHS 로 부터 응답 수신 대기
+	while( 1 )
+	{
+		// FHS 로 부터 응답 수신 처리
+		// -1 : 연결 종료
+		//  0 : Timeout 발생
+		//  1 : 응답 수신
+		//  2 : 복제 관련 응답이 아닌 다른 응답인 경우.. (발생하지 않지만.. 혹시나)
+		nResult = fhs.GetFileReplicationResult( FHS_RESPONSE_CHECK_TIMEOUT
+											, bSuccess
+											, szErrorMessage
+											, m_mapSuccessFhs
+											, m_mapFailFhs );
+				
+		if( nResult == 0 )
+		{
+			// 지정된 시간동안 응답 결과를 수신하지 못한 경우
+			// - FHS 와 연결이 정상인지 Alive 체크 호출
+			// - 만약 연결이 끝어진 경우.. 다음 loop 에서 -1 연결 종료가 리턴됨.
+			if( fhs.SendAliveCheck() == false )
+			{
+				_LOG( LERR, "CReplicateThread: alive check fail.[%s][%s]"
+					, m_dataJob.m_OriginData.m_szOriginHostName.c_str()
+					, m_dataJob.m_OriginData.m_szURI.c_str() );				
+			}
+
+			// Timeout 이 발생했으므로 바로 재시도하지 않고 조금 대기 후 다시 시도.
+			sleep( 1 );
+		}
+		else if( nResult == 1 )
+		{
+			// FHS 로 부터 응답을 수신한 경우.
+			// - Content 이상으로 인해 전송 자체를 하지 못했는지 여부 판단
+			if( bSuccess == true )
+			{
+				// 정상적으로 Replication 이 처리된 경우..
+				_LOG( LDBG, "CReplicateThread: result receive.[%s][%s]"
+					, m_dataJob.m_OriginData.m_szOriginHostName.c_str()
+					, m_dataJob.m_OriginData.m_szURI.c_str() );
+
+				DoSuccessProcess();
+			}
+			else
+			{
+				// Content 이상으로 인해 Replication 자체에 문제가 있는 경우.
+				_LOG( LERR, "CReplicateThread: error result receive.[%s][%s][%s][%llu]"
+					, szErrorMessage.c_str()
+					, m_dataJob.m_OriginData.m_szOriginHostName.c_str()
+					, m_dataJob.m_OriginData.m_szURI.c_str()
+					, m_dataJob.m_OriginData.m_nContentLength );
+				
+				DoErrorProcess( szErrorMessage );
+			}
+
+			// 처리 결과를 수신했으므로 loop 종료.
+			break;
+		}
+		else if( nResult == -1 )
+		{
+			// FHS 와 연결이 끝어진 경우.
+			// - retry queue 에 저장하고 본 루프는 종료
+			_LOG( LERR, "CReplicateThread: fhs connection broken.[%s][%s]"				
+				, m_dataJob.m_OriginData.m_szOriginHostName.c_str()
+				, m_dataJob.m_OriginData.m_szURI.c_str() );
+
+			DoFailProcess();
+			break;
+		}
+		else if( nResult == 2 )
+		{
+			// Replication 관련 응답이 아닌 경우
+			// - 무시
+			;
+		}
+		else
+		{
+			// 기타 정의되지 않은 결과값 반환시
+			// - FHS 와 세션 이상이 발생할 수 있으므로 
+			// - 실패로 처리하여 retry queue 에 저장하고 본 루프는 종료
+			_LOG( LERR, "CReplicateThread: receive undefine result.[%d][%s][%s]"
+				, nResult
+				, m_dataJob.m_OriginData.m_szOriginHostName.c_str()
+				, m_dataJob.m_OriginData.m_szURI.c_str() );
+
+			DoFailProcess();
+			break;
+		}
+
+		// Total Reponse 대기 시간 확인
+		if( difftime( time( &timeNow ), timeStart ) > FHS_RESPONSE_TOTAL_TIMEOUT )
+		{
+			// Total Response Timeout 발생시
+			// - 로깅 후 Retry Queue 에 저장 처리
+			// - 본 대기 루프를 종료 
+			_LOG( LERR, "CReplicateThread: replication result receive timeout.[%s][%s]"
+				, m_dataJob.m_OriginData.m_szOriginHostName.c_str()
+				, m_dataJob.m_OriginData.m_szURI.c_str() );
+
+			DoFailProcess();
+			break;
+		}
+
+	} // while( 1 )
+
+}
+
+// Replication 처리 관련 오류가 발생한 경우 처리 함수.
+// - 재시도 횟수를 확인하여
+// - Retry queue 에 저장 처리
+void CReplicateThread::DoFailProcess()
+{ 
+	// 재시도 횟수 초과 여부 확인.
+	if( m_dataJob.m_uFailCount + 1 > CServiceConfig::GetInstance()->GetMaxRetryCount() )
+	{
+		// 재시도 횟수 초과시
+		// - Report 로그에 기록하고 Retry Queue 에는 저장하지 않는다.
+		_LOG( LERR, "CReplicateThread: replicate thread fail and retry count over.[%s][%s]"
+			, m_dataJob.m_OriginData.m_szOriginHostName.c_str()
+			, m_dataJob.m_OriginData.m_szURI.c_str() );
+
+		CReportLog reportLog;
+		if( reportLog.Init( CServiceConfig::GetInstance()->GetLogPath() ) == false )
+		{
+			std::string strErrorMessage;
+			reportLog.GetLastError( strErrorMessage );
+
+			LOG( LERR, "report log init fail. [%s]", strErrorMessage.c_str() );			
+		}
+		else
+		{
+			reportLog.Write( "ERR", "[%s][Replication fail. check content[%s][%s]]"
+				, PROG_NAME
+				, m_dataJob.m_OriginData.m_szOriginHostName.c_str()
+				, m_dataJob.m_OriginData.m_szURI.c_str() );
+		}
+	}
+	else
+	{
+		// Retry Queue 에 저장 처리.
+		m_dataJob.m_uFailCount += 1;
+		m_dataJob.m_timeFailed = time( 0 );
+
+		// Retry Queue 가 Full 인 상태에서
+		// 작업 Thread 가 모두 Push 상태인 경우 무한 Block 상태 발생 가능...
+		// 하지만.. 실제 발생 가능이 희박하므로... 무한 재시도 처리.
+		while( m_pRetryQueue->Push( m_dataJob ) == false )
+		{
+			sleep( 1 );
+		}
+	}
+
+	return;
+}
+
+
+// Replication 처리에 대해 FHS 에서 실패로 응답한 경우.
+// - 대부분 Replication 대상 content 가 존재하지 않거나 Size 변경 등이 발생한 경우임.
+// - 따라서 해당 Content 에 대해서는 Retry 하지 않고.. Report 로그에만 기록하고 끝낸다.
+void CReplicateThread::DoErrorProcess( string& szErrorMessage )
+{
+	// 2017-11-15 CHG huibong 대량 report 로그 발생 관련 항목 조정 (#31526)
+	//  - 토토디스크 서비스에서 업로드에 따른 size mismatch 대량 report 로그 관련
+	//  - error message 가 "source file size not match" 인 경우 report 로그에 기록되지 않도록 수정한다.
+	//  - 실제 error message 내용은 "source file size not match.[ request: 877314616, local: 1137364384 ]" 형식이므로
+	//  - 앞의 일부분만 비교 처리.
+	if(strncmp(szErrorMessage.c_str(), "source file size not match", 26) == 0 )
+	{
+		return;
+	}
+	else
+	{
+		CReportLog reportLog;
+		if( reportLog.Init( CServiceConfig::GetInstance()->GetLogPath() ) == false )
+		{
+			std::string strErrorMessage;
+			reportLog.GetLastError( strErrorMessage );
+
+			LOG( LERR, "report log init fail. [%s]", strErrorMessage.c_str() );
+		}
+		else
+		{
+			reportLog.Write( "ERR", "[%s][Replication fail. check content[%s][%s][%llu][%s]]"
+							 , PROG_NAME
+							 , m_dataJob.m_OriginData.m_szOriginHostName.c_str()
+							 , m_dataJob.m_OriginData.m_szURI.c_str()
+							 , m_dataJob.m_OriginData.m_nContentLength
+							 , szErrorMessage.c_str() );
+		}
+
+		return;
+	}
+}
+
+
+// Replication 처리에 대해 FHS 에서 성공을 응답한 경우 처리함수
+// - 성공된 FHS 와 실패된 FHS 정보를 동시에 전달하므로 확인하여 처리해야 한다.
+void CReplicateThread::DoSuccessProcess()
+{
+	// 멤버 변수에 저장된 정보를 처리하기 위한 iterator
+	std::map<std::string, std::string>::iterator itSuccessFhs;
+	
+	// m_mapSuccessFhs 에 저장된 성공 결과에 대한 처리
+	// - success fhs host, hash_name 의 정보 저장된 상태
+	// - Complete Queue 에 저장.
+	for( itSuccessFhs = m_mapSuccessFhs.begin(); itSuccessFhs != m_mapSuccessFhs.end(); ++itSuccessFhs )
+	{
+		// complete queue 에 저장하기 위한 객체 조립
+		CCompleteData completeResult;
+		completeResult.m_OriginData           = m_dataJob.m_OriginData;
+		completeResult.m_szTargetHostName     = itSuccessFhs->first;
+		completeResult.m_szTargetFileNameHash = itSuccessFhs->second;
+
+		// complete queue 에 저장 처리
+		// - complete queue 가 full 상태일 수 있어 push 실패 가능성 존재
+		// - 하지만... complete queue 에 저장 못할 경우...
+		//   FHS 에 생성된 replication 은 처치 곤란한 쓰레기가 될 수 있으므로....
+		//   최대한 push 처리한다.
+		while( m_pCompleteQueue->Push( completeResult ) == false )
+		{
+			// push 실패시 잠시 대기 후 재시도
+			sleep( 1 );
+		}
+
+		// 원본 Data 객체에 성공한 FHS 정보 입력 처리
+		// - 일부 FHS 에만 복제 성공하고... 다른 FHS 복제는 실패한 경우...
+		// - Retry 를 통해 복제가 재시도 되도록 하기 위함.
+		m_dataJob.m_listSuccessHost.push_back( completeResult.m_szTargetHostName );
+	}
+
+	// m_mapFailFhs 에 저장된 실패 결과에 대한 처리
+	// - 재시도 횟수 초과시 Report 로그 기록 후 버림
+	// - 재시도 횟수 이하인 경우 fail count 증가 후 Retry Queue 에 저장 
+	if( m_mapFailFhs.empty() == false )
+	{
+		// 멤버 변수에 저장된 정보를 처리하기 위한 iterator
+		// - failed fhs host, error message
+		std::map<std::string, std::string>::iterator itFailFhs;
+
+		// 실패 내역에 대한 로깅		
+		for( itFailFhs = m_mapFailFhs.begin(); itFailFhs != m_mapFailFhs.end(); ++itFailFhs )
+		{
+			_LOG( LWAR, "CReplicateThread: replicate fail [%s]->[%s][%s]"				
+				, m_dataJob.m_OriginData.m_szURI.c_str()
+				, itFailFhs->first.c_str()
+				, itFailFhs->second.c_str() );
+		}
+
+		// 재시도 횟수 확인 처리 및 Retry queue 관련 처리
+		DoFailProcess();		
+	}
+
+	return;
+}

rcts/rc_rmcd/src/ReplicateThread.h

@@ -0,0 +1,108 @@
+/***************************************************************************
+           Content 에 대한 실제 Replication 처리를 수행하는 Thread class
+                -----------------------------------------
+    begin      : 2010/03/13
+    copyright  : (C) 2010 Solbox Inc.
+    author     : storage dev team
+    email      : storage.sd@solbox.com
+    version    : 3.3
+
+    CopyRight(C) 2010 Solbox Inc. All Rights reserved.
+    Redistribution and use in source and binary forms, with or with out
+    modification, are not permitted in outside of Solbox Inc.
+***************************************************************************/
+
+#ifndef __REPLICATE_THREAD_H__
+#define __REPLICATE_THREAD_H__
+
+
+#include <vector>
+#include <map>
+#include <string>
+#include <pthread.h>
+
+#include "ProcessStatus.h"
+#include "DataQueue.hpp"
+#include "ReplicationData.h"
+
+// CReplicateThread
+// 전달받은 Content 에 대해 각 FHS 와 통신을 통해 실제 Replication 생성을 수행
+// - Replicate 정보 및 FHS 정보를 SocketControl 을 이용하여 ftsd 로 전송
+// - 처리 결과 수신 후 CompletQueue 또는 RetryQueue 상에 저장처리
+// 내부적으로 Thread를 사용
+class CReplicateThread
+{
+    public:
+        
+		// 생성자
+		CReplicateThread( CProcessStatus* const pProcessStatus
+			            , CDataQueue<CRetryData>* const pQueueRetry
+						, CDataQueue<CCompleteData>* const pQueueComplete
+						, CRetryData& dataJob
+						, std::vector<std::string>& vecTargetFHS );
+
+		// 소멸자
+        ~CReplicateThread();
+        
+		// thread를 생성하여 업무 flow 를 시작.
+        bool Start();
+		        
+
+    private:
+
+		// 스레드 함수
+		static void* threadFunc( void* arg );
+
+		// 실제 Replication 생성 작업을 수행
+		void Execute();
+
+		// Replication 처리 관련 오류가 발생한 경우 처리 함수.
+		// - 재시도 횟수를 확인하여
+		// - Retry queue 에 저장 처리
+		void DoFailProcess();
+
+		// Replication 처리에 대해 FHS 에서 실패로 응답한 경우.
+		// - 대부분 Replication 대상 content 가 존재하지 않거나 Size 변경 등이 발생한 경우임.
+		// - 따라서 해당 Content 에 대해서는 Retry 하지 않고.. Report 로그에만 기록하고 끝낸다.
+		void DoErrorProcess( std::string& szErrorMessage );
+		
+		// Replication 처리에 대해 FHS 에서 성공을 응답한 경우 처리함수
+		// - 성공된 FHS 와 실패된 FHS 정보를 동시에 전달하므로 확인하여 처리해야 한다.
+		void DoSuccessProcess();
+		
+
+	private:
+
+        // 쓰레드 핸들
+        pthread_t m_threadHandle;
+        
+		// 프로세스 상의 Queue, Thread 상태를 관리하는 CProcessStatus 객체에 대한 포인터
+		// - 생성자를 통해 전달받음        
+		CProcessStatus * m_pProcessStatus;
+		        
+		// 복제 처리 관련 재시도 Content 정보를 관리하는 Queue 객체에 대한 포인터
+		// - 생성자를 통해 전달받음
+		CDataQueue<CRetryData> * m_pRetryQueue;
+
+		// 복제 완료된 Content 정보를 관리하는 Queue 객체에 대한 포인터
+		// - 생성자를 통해 전달받음
+		CDataQueue<CCompleteData> * m_pCompleteQueue;
+        
+		// 복제 대상 Content 정보 저장 객체
+		// - 생성자를 통해 전달받음
+		CRetryData m_dataJob;
+
+		// 복제본을 저장할 Proper FHS 저장 객체
+		// - 생성자를 통해 전달받음
+		std::vector<std::string> m_vecTargetFHS;
+
+		// ftsd 로 부터 정상 처리된 결과 정보를 수신하기 위한 멤버 객체
+		// - success fhs host, hash_name
+		std::map<std::string, std::string> m_mapSuccessFhs;
+
+		// ftsd 로 부터 실패 처리된 결과 정보를 수신하기 위한 멤버 객체
+		// - failed fhs host, error message
+		std::map<std::string, std::string> m_mapFailFhs;
+
+};
+#endif // __REPLICATE_THREAD_H__

rcts/rc_rmcd/src/ReplicationData.h

@@ -0,0 +1,84 @@
+/***************************************************************************
+                   Replication 관련 Data 객체 정의
+                -----------------------------------------
+	begin      : 2010/03/09
+	copyright  : (C) 2005 Solbox Inc.
+	author     : Storage Dev Team
+	email      : storage.sd@solbox.com
+	version    : 3.3
+
+	CopyRight(C) 2005 Solbox Inc. All Rights reserved.
+	Redistribution and use in source and binary forms, with or with out
+	modification, are not permitted in outside of Solbox Inc.
+***************************************************************************/
+
+#ifndef __REPLICATION_DATA_H__
+#define __REPLICATION_DATA_H__
+
+#include <list>
+#include <string>
+#include <time.h>
+
+// CSourceData class
+class CSourceData
+{
+	public :
+		// RCDB 의 URI 정보
+		std::string  m_szURI;
+		// RCDB의 filename_hash 정보
+		std::string  m_szFileNameHash;
+		// RCDB의 hostname 정보
+		std::string  m_szOriginHostName;
+		
+		// NEW 2014-06-16
+		// 서비스별 RCDB table 분리 (RCDB 신규 형상)에 따라...
+		// Query 처리가 간편하도록 서비스 정보 필드 추가 (RCDB sp_svc_tran_id, CCDB svc_seq )
+		std::string m_szServiceSeq;
+				
+		// 파일의 크기. RCDB의 get_content_length
+		unsigned long long m_nContentLength;
+
+		// Replication 해야할 갯수
+		int m_nReplicationCount;
+	
+};
+
+
+// CRetryData class
+class CRetryData
+{
+	public :
+		// 실패 개수
+		unsigned int  m_uFailCount;
+		
+		// 실패 시각(default=now)
+		time_t  m_timeFailed;
+		
+		// 성공한 FHS 정보
+		std::list<std::string> m_listSuccessHost;
+		
+		// 작업 시도 대상(source 정보)
+		CSourceData m_OriginData;
+
+		// 생성자. 현재 시각으로 time설정
+		inline CRetryData() { time(&m_timeFailed); }
+
+};
+
+
+// CCompleteData class
+class CCompleteData
+{
+	public :
+		// content 가 생성된 장비 host name
+		std::string  m_szTargetHostName;
+
+		// 생성된 content 의 filename_hash 정보
+		std::string  m_szTargetFileNameHash;
+		
+		// 원본 정보
+		CSourceData m_OriginData;
+};
+
+
+#endif // __REPLICATION_DATA_H__

rcts/rc_rmcd/src/ServiceConfig.cpp

@@ -0,0 +1,440 @@
+#include "ServiceConfig.h"
+
+#include <stdlib.h>
+
+#include "Logger.h"
+
+
+// static 변수 초기화
+CServiceConfig * CServiceConfig::m_pInstance = NULL;
+
+
+// 생성자
+CServiceConfig::CServiceConfig()
+{
+	// default 값 설정.
+	// 지정된 conf 파일에 해당 설정이 없어도 동작되도록 처리할 값에 대해서만 default 값을 정의한다.	
+
+}
+
+// 소멸자 
+CServiceConfig::~CServiceConfig()
+{
+	// 객체 소멸시... 
+	// 만약 static GetInstance() 함수가 가르키는 객체가 자기 자신이라면...
+	// 소멸 처리에 의해 문제가 발생할 수 있으므로... 이에 대한 처리를 해 준다.
+	if( CServiceConfig::GetInstance() == this )
+	{
+		CServiceConfig::m_pInstance = NULL;
+	}
+
+}
+
+bool CServiceConfig::Init( const std::string strProgramName, const std::string & strConfFileName, std::string & strErrorMessage )
+{
+
+	// 1. 임시 처리용 Instance 를 생성한다.
+	CServiceConfig * pTempInstance = new CServiceConfig();
+
+	// 2. 전달 받은 Config 정보를 임시 Instance 로 로딩한다.
+	//   - 만약 로딩이 실패할 경우... 임시 Instance 객체를 삭제 처리한다.
+	if( pTempInstance->Load( strProgramName, strConfFileName, strErrorMessage ) == false )
+	{
+		delete pTempInstance;
+		pTempInstance = NULL;
+
+		return false;	// 생성 실패 사유는 Error String 관련 함수를 사용하여 확인.
+	}
+
+	// 3. 전달받은 Conf 정보 로딩에 성공한 경우...
+	//   - 기존 Instance 객체가 존재하는 경우.. 교체 처리..
+	//   - 기존 Instance 객체가 없는 경우는 신규 Instance 사용토록 처리.
+	if( CServiceConfig::GetInstance() == NULL )
+	{
+		CServiceConfig::m_pInstance = pTempInstance;
+	}
+	else
+	{
+		// Instance replace...
+		CServiceConfig * pPreviosInstance = CServiceConfig::m_pInstance;
+		CServiceConfig::m_pInstance = pTempInstance;
+		
+		delete pPreviosInstance;
+	}
+
+	return true;
+}
+
+
+CServiceConfig * CServiceConfig::GetInstance( ) 
+{ 
+	return CServiceConfig::m_pInstance; 
+}
+
+
+bool CServiceConfig::Load( const std::string & strProgramName, const std::string & strConfFileName, std::string & strErrorMessage )
+{
+	// 변수 유효성 확인
+	if( strProgramName.size() <= 0 )
+	{
+		strErrorMessage = "Config Program Name[" + strProgramName + "] not valid.";
+		return false;
+	}
+
+	// Config class (lib 하위) 를 이용하여 config 파일 상의 정보를 로딩 처리 
+	Config conf;
+
+	if( conf.Open( strConfFileName ) == false )
+	{
+		strErrorMessage = "Config file[" + strConfFileName + "] open failed.";
+		return false;
+	}
+
+	// Config 모듈에 로딩된 정보 중 필요한 정보만 가져온다...
+	// - 만약 오류가 발생할 경우... 해당 내역은 Error String 에 저장 처리...
+
+	std::string strValue;
+	int nValue;
+	std::vector< std::string > vecValue;
+
+	
+	// Log path
+	if( GetConfigValue( conf, strProgramName, "DEFAULT_LOG_DIR", strValue, strErrorMessage ) == false )
+		return false;
+	else
+	{
+		m_strLogPath = strValue;
+		strValue.clear();
+	}
+
+	// Log Level
+	if( GetConfigValue( conf, strProgramName, "LOG_LEVEL", strValue, strErrorMessage ) == false )
+		return false;
+	else
+	{
+		nValue = atoi(strValue.c_str());		
+		if( nValue < 0 || nValue > MAX_LOG_LEVEL )
+		{
+			strErrorMessage = "Config [LOG_LEVEL] value[" + strValue + "] is not valid";
+			return false;
+		}
+		else
+			m_nLogLevel = nValue;
+		
+		strValue.clear();
+	}
+
+	// RC ID
+	if( GetConfigValue( conf, strProgramName, "RC_ID", strValue, strErrorMessage ) == false )
+		return false;
+	else
+	{
+		m_strRcId = strValue;
+		strValue.clear();
+	}
+
+	// RCDB IP
+	if( GetConfigValue( conf, strProgramName, "RCDB_IP", strValue, strErrorMessage ) == false )
+		return false;
+	else
+	{
+		m_strRcdbIp = strValue;
+		strValue.clear();
+	}
+
+	// RCDB PORT
+	if( GetConfigValue( conf, strProgramName, "RCDB_PORT", strValue, strErrorMessage ) == false )
+		return false;
+	else
+	{
+		nValue = atoi(strValue.c_str());
+		if( nValue <= 0 || nValue > 65535 )
+		{
+			strErrorMessage = "Config [RCDB_PORT] value[" + strValue + "] is not valid";
+			return false;
+		}
+		else
+			m_nRcdbPort = nValue;
+		
+		strValue.clear();
+	}
+
+	// RCDB DB NAME
+	if( GetConfigValue( conf, strProgramName, "RCDB_DB_NAME", strValue, strErrorMessage ) == false )
+		return false;
+	else
+	{
+		m_strRcdbName = strValue;
+		strValue.clear();
+	}
+
+	// RCDB ACCOUNT
+	if( GetConfigValue( conf, strProgramName, "RCDB_ACCT", strValue, strErrorMessage ) == false )
+		return false;
+	else
+	{
+		m_strRcdbAcct = strValue;
+		strValue.clear();
+	}
+
+	// RCDB ACCOUNT PASSWORD
+	if( GetConfigValue( conf, strProgramName, "RCDB_ACCT_PW", strValue, strErrorMessage ) == false )
+		return false;
+	else
+	{
+		m_strRcdbAcctPw = strValue;
+		strValue.clear();
+	}
+
+	// FHS FTSD (File TranSfer Daemon) Service Port
+	if( GetConfigValue( conf, strProgramName, "FHS_TRANSFER_DAEMON_PORT", strValue, strErrorMessage ) == false )
+		return false;
+	else
+	{
+		nValue = atoi(strValue.c_str());
+		if( nValue <= 0 || nValue > 65535 )
+		{
+			strErrorMessage = "Config [FHS_TRANSFER_DAEMON_PORT] value[" + strValue + "] is not valid";
+			return false;
+		}
+		else
+			m_nFhsTransferDaemonPort = nValue;
+		
+		strValue.clear();
+	}
+
+	// Max Queue Count(size) limit ( 0: infinite )
+	if( GetConfigValue( conf, strProgramName, "MAX_QUEUE_COUNT", strValue, strErrorMessage ) == false )
+		return false;
+	else
+	{
+		nValue = atoi(strValue.c_str());
+		if( nValue < 0 )
+		{
+			strErrorMessage = "Config [MAX_QUEUE_COUNT] value[" + strValue + "] is not valid";
+			return false;
+		}
+		else
+			m_nMaxQueueSize = nValue;
+		
+		strValue.clear();
+	}
+
+	// Max Retry Count if file processing failed.
+	if( GetConfigValue( conf, strProgramName, "MAX_RETRY_COUNT", strValue, strErrorMessage ) == false )
+		return false;
+	else
+	{
+		nValue = atoi(strValue.c_str());
+		if( nValue < 0 )
+		{
+			strErrorMessage = "Config [MAX_RETRY_COUNT] value[" + strValue + "] is not valid";
+			return false;
+		}
+		else
+			m_nMaxRetryCount = nValue;
+		
+		strValue.clear();
+	}
+
+	// File Hash Check Level: 0:Not use hash, 1:Partitial hash(Default), 2:Full Hash
+	if( GetConfigValue( conf, strProgramName, "FILE_HASH_CHECK_LEVEL", strValue, strErrorMessage ) == false )
+		return false;
+	else
+	{
+		nValue = atoi(strValue.c_str());
+		if( nValue < 0 || nValue > 2)
+		{
+			strErrorMessage = "Config [FILE_HASH_CHECK_LEVEL] value[" + strValue + "] is not valid";
+			return false;
+		}
+		else
+			m_nHashCheckLevel = nValue;
+
+		strValue.clear();
+	}
+
+	// Max count of file replication request thread
+	if( GetConfigValue( conf, strProgramName, "MAX_REPLICATION_THREAD", strValue, strErrorMessage ) == false )
+		return false;
+	else
+	{
+		nValue = atoi(strValue.c_str());
+		if( nValue <= 0 )
+		{
+			strErrorMessage = "Config [MAX_REPLICATION_THREAD] value[" + strValue + "] is not valid";
+			return false;
+		}
+		else
+			m_nMaxReplicationThread = nValue;
+		
+		strValue.clear();
+	}
+
+	// FHS Hot contents 정보 수신을 위한 TCP Listen Port
+	if( GetConfigValue( conf, strProgramName, "FHS_HOTCONTENT_LISTEN_TCP_PORT", strValue, strErrorMessage ) == false )
+		return false;
+	else
+	{
+		nValue = atoi(strValue.c_str());
+		if( nValue <= 0 || nValue > 65535 )
+		{
+			strErrorMessage = "Config [FHS_HOTCONTENT_LISTEN_TCP_PORT] value[" + strValue + "] is not valid";
+			return false;
+		}
+		else
+			m_nFhsHotContentListenPort = nValue;
+		
+		strValue.clear();
+	}
+
+	// Hot content cache 생성을 위한 최소 동접 fd 설정값.
+	if( GetConfigValue( conf, strProgramName, "HOTCONTENT_CREATE_MINIMUM_FD_COUNT", strValue, strErrorMessage ) == false )
+		return false;
+	else
+	{
+		nValue = atoi( strValue.c_str() );
+		if( nValue < 0 )
+		{
+			strErrorMessage = "Config [HOTCONTENT_CREATE_MINIMUM_FD_COUNT] value[" + strValue + "] is not valid";
+			return false;
+		}
+		else
+			m_nCacheCreateMinimumFdCount = nValue;
+
+		strValue.clear();
+	}
+		
+	// Cache File Timeout (sec) (Default: 24Hour)
+	if( GetConfigValue( conf, strProgramName, "CACHE_FILE_TIMEOUT", strValue, strErrorMessage ) == false )
+		return false;
+	else
+	{
+		nValue = atoi(strValue.c_str());
+		if( nValue <= 0 )
+		{
+			strErrorMessage = "Config [CACHE_FILE_TIMEOUT] value[" + strValue + "] is not valid";
+			return false;
+		}
+		else
+			m_nCacheFileTimeout = nValue;
+		
+		strValue.clear();
+	}
+
+	// Max count of file cache request thread
+	if( GetConfigValue( conf, strProgramName, "MAX_CACHE_THREAD", strValue, strErrorMessage ) == false )
+		return false;
+	else
+	{
+		nValue = atoi(strValue.c_str());
+		if( nValue <= 0 )
+		{
+			strErrorMessage = "Config [MAX_CACHE_THREAD] value[" + strValue + "] is not valid";
+			return false;
+		}
+		else
+			m_nMaxCacheThread = nValue;
+		
+		strValue.clear();
+	}
+
+	// Target select interval on running
+	if( GetConfigValue( conf, strProgramName, "TARGET_SELECT_INTERVAL", strValue, strErrorMessage ) == false )
+		return false;
+	else
+	{
+		nValue = atoi(strValue.c_str());
+		if( nValue < 0 )
+		{
+			strErrorMessage = "Config [TARGET_SELECT_INTERVAL] value[" + strValue + "] is not valid";
+			return false;
+		}
+		else
+			m_nTargetSelectInterval = nValue;
+		
+		strValue.clear();
+	}
+
+	// Target select interval on starting
+	if( GetConfigValue( conf, strProgramName, "TARGET_SELECT_INTERVAL_ON_STARTING", strValue, strErrorMessage ) == false )
+		return false;
+	else
+	{
+		nValue = atoi(strValue.c_str());
+		if( nValue < 0 )
+		{
+			strErrorMessage = "Config [TARGET_SELECT_INTERVAL_ON_STARTING] value[" + strValue + "] is not valid";
+			return false;
+		}
+		else
+			m_nTargetSelectIntervalOnStarting = nValue;
+		
+		strValue.clear();
+	}
+	
+	// Skip keyword : h|path (head) or m|path(middle) or t|path(tail)
+	// - 본 설정갑은 없어도 동작하도록 처리한다.
+	
+	// CHG 2014-09-02 huibong
+	// program -> common section 변경에 따른 기능 추가 처리 ( #20201 )
+	if( conf.GetConfig( strProgramName, "SKIP_KEYWORD", vecValue ) == true )
+	{
+		// 해당 값이 존재할 경우..	
+		// Multi value 이므로 갯수 검사
+		if( vecValue.size() > 0 )
+		{
+			m_vecSkipWord = vecValue;			
+		}
+
+		vecValue.clear();
+	}
+	else
+	{
+		// program section 에 존재하지 않을 경우... COMMON 세션 확인
+		if( conf.GetConfig( "COMMON", "SKIP_KEYWORD", vecValue ) == true )
+		{
+			// 해당 값이 존재할 경우..	
+			// Multi value 이므로 갯수 검사
+			if( vecValue.size() > 0 )
+			{
+				m_vecSkipWord = vecValue;			
+			}
+
+			vecValue.clear();
+		}
+	}
+
+
+
+	// conf 정보 로딩이 모두 정상적으로 완료된 경우... 
+	// 마지막으로 전달받은 config 명, section 정보를 저장한다.
+	m_strConfigFileName = strConfFileName;
+	m_strProgramName    = strProgramName;
+	
+	return true;
+}
+
+
+bool CServiceConfig::GetConfigValue( Config & conf, const std::string & strProgramName, const std::string strKey, std::string & strValue, std::string & strErrorMessage )
+{
+	// conf get value
+	if( conf.GetConfig( strProgramName, strKey, strValue) == false )
+	{
+		if( conf.GetConfig( "COMMON", strKey, strValue) == false )
+		{
+			strErrorMessage = "Config [" + strKey + "] value is not exist";
+
+			return false;
+		}
+	}
+
+	// value check.
+	if( strValue.empty() == true )
+	{
+		strErrorMessage = "Config [" + strKey + "] value is not valid";
+		return false;
+	}
+	
+	return true;
+}

rcts/rc_rmcd/src/ServiceConfig.h

@@ -0,0 +1,163 @@
+/****************************************************************************
+                rc_rmcd's service config module 
+                -----------------------------------------
+
+    begin      : 2014/05/19
+    copyright  : (C) 2005 Solbox Inc.
+    author     : Dev 1 Team 
+	                 - huibong : 최초 작성
+    email      : dev1@solbox.com
+    version    : 3.4.0
+
+    CopyRight(C) 2005 Solbox Inc. All Rights reserved.
+    Redistribution and use in source and binary forms, with or with out
+    modification, are not permitted in outside of Solbox Inc.
+*****************************************************************************/
+
+#ifndef __SERVICE_CONFIG_H__
+#define __SERVICE_CONFIG_H__
+
+#include <string>
+
+#include "Config.h"
+
+// 본 모듈은 conf 파일의 정보를 read 하여... 본 프로세스 관련 설정 정보를 저장한다.
+// 본 모듈은 singleton 으로 동작시켜 Main 프로세스 및 Worker 프로세스에서도 접근이 가능토록 한다.
+// conf 파일에 대한 파싱 및 설정 정보 추출은 lib 하위의 Config 클래스를 이용한다.
+// 본 객체는 singleton 객체이므로 상속받아 사용하지 않도록 한다. ( 상속받아 사용할 수 없도록 private 처리함 )
+
+class CServiceConfig
+{
+	
+	private:
+
+		// sigleton 객체 생성을 위해 생성자를 public 으로 처리하지 않음.
+		CServiceConfig();
+	
+		// 소멸자
+		virtual ~CServiceConfig();
+
+		static CServiceConfig * m_pInstance;
+
+
+	public:
+
+		// 객체 초기화 처리용 Function.
+		// 본 함수 호출시 Instance 생성 후 입력 받은 Config 파일 load.
+		// 따라서 본 함수를 호출하지 않을 경우.. GetInstance() 함수는 NULL 을 반환
+		// 본 함수를 객체가 생성된 상태에서 재 호출할 경우 
+		// - 주어진 Conf 파일 정보가 정확하다면.. conf 정보를 다시 load 함.
+		// - 주어진 conf 파일 정보가 부정확하다면... 이전 conf 를 계속 사용함.
+		static bool Init( const std::string strProgramName, const std::string & strConfFileName, std::string & strErrorMessage );
+		
+		// Singleton 객체 접근 메소드
+		static CServiceConfig * GetInstance(); 
+
+
+	private:
+
+		// 전달받은 conf 파일에서 해당 config 정보를 로드하여 멤버 변수에 저장한다.
+		// 만약 반환값이 false 인 경우 해당 오류 관련 내역은 strErrorMessage 변수에 저장된다.
+		bool Load( const std::string & strProgramName, const std::string & strConfFileName, std::string & strErrorMessage );
+
+
+		// Config 객체로 부터 지정된 strKey 정보를 가져와 유효성 여부를 판단.
+		// 반환값이 false 인 경우 strErrorMessage 상에 오류 내역이 저장된다.
+		bool GetConfigValue( Config & conf, const std::string & strProgramName, const std::string strKey, std::string & strValue, std::string & strErrorMessage );
+
+
+	private:
+
+		// 객체 초기화시 전달받은 정보 
+		std::string m_strConfigFileName;		// 설정 파일 정보
+		std::string m_strProgramName;			// 프로그램 명 (conf 상에서 해당 프로그램의 설정 정보를 가져올 때 사용)
+
+
+		// 기본 설정 정보.
+		std::string m_strLogPath;				// 로그 저장 Path
+		int m_nLogLevel;						// 로그 기록 Level
+
+		std::string m_strRcId;					// RC ID
+
+		std::string m_strRcdbIp;				// RCDB IP
+		unsigned int m_nRcdbPort;				// RCDB Port
+		std::string m_strRcdbName;				// RCDB DB Name
+		std::string m_strRcdbAcct;				// RCDB 접근 계정
+		std::string m_strRcdbAcctPw;			// RCDB 접근 Password.
+
+		
+		// Process 공통
+		unsigned int m_nHashCheckLevel;				// Content 복제 및 Cache 관련 전송시 Hash Check Level 설정.
+		                                            // 0:Not use hash, 1:Partitial hash(Default), 2:Full Hash
+		unsigned int m_nFhsTransferDaemonPort;		// FHS File Transfer Daemon (ftsd) 의  TCP Listen Port = 14001 (default)
+		
+		// Replication 관련 설정 정보				
+		unsigned int m_nMaxQueueSize;				// Max Queue Size ( 0: infinite, 4096: default )
+		unsigned int m_nMaxRetryCount;				// 복제 실패 발생시 최대 재시도 횟수, ( default 2 )
+
+		unsigned int m_nMaxReplicationThread;		// 동시 수행 Replication Thread 의 최대 갯수
+
+		unsigned int m_nTargetSelectInterval;		// 현재 시간을 기준으로 지정된 시간 이전의 Content 에 대해서만 replication 대상 여부를 조회
+		                                            // 금방 업로드된 Content 의 경우.. 수정, 삭제 등의 추가 작업 발생이 가능하므로... 
+													// 되도록 추가 작업이 완료된 Cotnent 에 대해서 Replication 이 수행될 수 있도록 
+													// 지정된 시간동안 Delay 처리, 이로 인해 지정된 시간만큼 지연 복제가 발생된다.
+													// range : 180 ~ 1800 (second)
+
+		unsigned int m_nTargetSelectIntervalOnStarting;   // 최초 기동시 Replication 대상 조회 범위를 지정
+		                                                  // 본 설정값만큼 과거 Content 중에서 Replicaton 대상을 조회한다.
+														  // 본 설정값은 기동시 1번만 적용된다.
+														  // range : 1 ~ unlimited (hour) (Default: 168Hour(7Days))
+
+		std::vector<std::string> m_vecSkipWord;		// 복제 대상에서 제외할 문자열 정보 저장.
+		                                            // 설정값이 존재하지 않을 수 있음.
+		
+		// Hot Content Cache 관련 설정 정보
+		unsigned int m_nFhsHotContentListenPort;	// FHS fimngd 에서 전송하는 Hot Content 관련 TCP Data 수신을 위한 TCP Port = 13110
+
+		unsigned int m_nCacheCreateMinimumFdCount;  // Hot content cache 생성을 위한 최소 동접 fd 설정값.
+		                                            // - fimngd 로 부터 전송받은 정보 중 본 설정값 이상인 Content 에 대해서만 Cache 생성을 시도한다.
+		
+		unsigned int m_nCacheFileTimeout;			// Cache 목적으로 생성된 Content 의 최대 생존 시간 (sec, default 84600 = 24hour )
+
+		unsigned int m_nMaxCacheThread;				// 동시 수행 Cache 생성 Thread 의 최대 갯수
+
+
+		
+	public:	// 멤버 변수에 대한 Get 함수 선언 및 정의
+
+		const char * GetConfigFileName()          { return m_strConfigFileName.c_str(); }
+		const char * GetProgramName()             { return m_strProgramName.c_str(); }
+
+		const char * GetLogPath()                 { return m_strLogPath.c_str(); }
+		int          GetLogLevel()                { return m_nLogLevel; }
+
+		const char * GetRcId()                    { return m_strRcId.c_str(); }
+
+		const char * GetRcdbIp()                  { return m_strRcdbIp.c_str(); }
+		unsigned int GetRcdbPort()                { return m_nRcdbPort; }
+		const char * GetRcdbName()                { return m_strRcdbName.c_str(); }
+		const char * GetRcdbAcct()                { return m_strRcdbAcct.c_str(); }
+		const char * GetRcdbAcctPw()              { return m_strRcdbAcctPw.c_str(); }
+
+		unsigned int GetHashCheckLevel()                 { return m_nHashCheckLevel; }
+		unsigned int GetFhsTransferDaemonPort()          { return m_nFhsTransferDaemonPort; }
+						
+		unsigned int GetMaxQueueSize()                   { return m_nMaxQueueSize; }
+		unsigned int GetMaxRetryCount()                  { return m_nMaxRetryCount; }
+		unsigned int GetMaxReplicationThread()           { return m_nMaxReplicationThread; }
+		unsigned int GetTargetSelectInterval()           { return m_nTargetSelectInterval; }
+		unsigned int GetTargetSelectIntervalOnStarting() { return m_nTargetSelectIntervalOnStarting; }
+		std::vector<std::string> GetSkipWord()           { return m_vecSkipWord; }
+
+		unsigned int GetFhsHotContentListenPort()        { return m_nFhsHotContentListenPort; }
+		unsigned int GetHotContentCreateMinimumFd()      { return m_nCacheCreateMinimumFdCount; }
+		unsigned int GetMaxCacheThread()                 { return m_nMaxCacheThread; }
+		unsigned int GetCacheFileTimeout()               { return m_nCacheFileTimeout; }
+		
+	
+		
+
+};
+
+#endif /* __SERVICE_CONFIG_H__ */
+

rcts/rc_rmcd/src/Util.cpp

@@ -0,0 +1,40 @@
+#include "Util.h"
+
+#include <sys/time.h>
+
+#define SEC_TO_MICROSEC    (1000000LL)
+
+
+/// @brief  현재 시간 정보를 micro-second 단위로 계산하여 반환
+/// @return 1970년 1월 1일 이후부터의 현재시간을 micro-second(1/1,000,000) 단위로 반환처리, 오류발생시에는 -1 값을 반환.
+long long longtime_now()
+{
+	struct timeval tv;
+	
+	if( gettimeofday(&tv, NULL) == 0 )
+	{
+		// 성공시 micro-second 단위의 값을 반환
+		return tv.tv_sec * SEC_TO_MICROSEC + tv.tv_usec;
+	}
+	else
+	{
+		// 실패시 -1 값을 반환.
+		return -1;
+	}
+}
+
+/// @brief  source string에 주어진 search string을 replacement로 변환 화여 반환
+std::string stringreplace(const std::string& source, const std::string search, const std::string replacement) 
+{
+	std::string r = source;
+
+	std::string::size_type pos = 0;
+
+	while ( (pos = r.find(search, pos)) != std::string::npos ) 
+	{
+		r.replace( pos, search.size(), replacement );
+		pos = pos + replacement.size();		
+	}
+
+	return r;
+}

rcts/rc_rmcd/src/Util.h

@@ -0,0 +1,44 @@
+/***************************************************************************
+                Util functions
+                -----------------------------------------
+    begin      : 2010/03/13
+    copyright  : (C) 2010 SolutionBox Inc.
+    author     : Tae-il, KIm
+    email      : tael@solbox.com
+    version    : 1.0
+
+    CopyRight(C) 2010 SolutionBox Inc. All Rights reserved.
+    Redistribution and use in source and binary forms, with or with out
+    modification, are not permitted in outside of SolutionBox Inc.
+***************************************************************************/
+/* 수정일     /수정자   : 수정 내역
+ * 2010-03-31 / huibong : gettimeofday() 함수 반환값에 대한 처리 추가, C++ Style extern 선언 추가.
+ */
+
+#ifndef __UTIL_H__
+#define __UTIL_H__
+
+
+#include <string>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+	/// @brief  현재 시간 정보를 micro-second 단위로 계산하여 반환.
+	/// @return 1970년 1월 1일 이후부터의 현재시간을 micro-second(1/1,000,000) 단위로 반환처리, 오류발생시에는 -1 값을 반환.
+	long long longtime_now(void);
+
+	/// @brief  source string에 주어진 search string을 replacement로 변환 화여 반환
+	std::string stringreplace(const std::string& source, const std::string search, const std::string replacement);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+
+#endif // __UTIL_H__

rcts/rc_rmcd/src/Worker.cpp

@@ -0,0 +1,586 @@
+#include "Worker.h"
+
+#include "ProcessRename.h"
+#include "ServiceConfig.h"
+#include "Logger.h"
+#include "DataQueue.hpp"
+#include "ReplicationData.h"
+#include "CacheRequestData.h"
+#include "CacheData.h"
+#include "ProcessStatus.h"
+#include "ReplicateSelect.h"
+#include "ReplicateInsert.h"
+#include "ProperFhs.h"
+#include "ReplicateControl.h"
+#include "FimngdSocketControl.h"
+#include "CacheJobList.h"
+#include "CacheDelete.h"
+#include "CacheInsert.h"
+#include "CacheOrder.h"
+#include "CacheControl.h"
+
+#include <unistd.h>
+#include <signal.h>
+#include <netinet/in.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <time.h>
+
+
+// hot content 정보 관련 fimngd 로 부터 TCP 접속 요청 수신시
+// 이를 처리할 Thread 에게 전달할 정보 구조체
+struct stFhsReceiveThreadArg {
+
+	// client socket descriptor
+	int clientSocketDesc;
+
+	// Client 의 IP 주소 정보를 저장한 변수
+	char szClientAddress[INET_ADDRSTRLEN];
+
+	// 요청된 Cache 정보를 저장하기 위한 Queue 에 대한 포인터.
+	CDataQueue<CCacheRequestData> * pQueueCacheRequest;
+};
+
+
+/// @brief Worker Process 의 main 함수
+int WorkerMain( int socketListenHotContent )
+{
+	// Process Rename
+	set_ps_display(PROG_NAME": Worker [initialize process]", false);
+
+	// Set Signal Handler
+	SetSignalWorker();
+    
+	// 로그 출력 순서가 Main 프로세스와 꼬여서... 1초간 대기 후 진행
+	sleep( 1 );
+	
+
+
+	// 1. 각 모듈 생성 및 초기화.
+	//    - 초기화 실패시 EXIT_FAILURE 를 return 하여 프로세스가 종료되도록 한다.
+	
+	// 1.1 Data 처리를 위한 객체 생성
+	
+	// 복제대상 정보를 관리하는 큐.
+	CDataQueue<CSourceData> queueReplicate;
+	queueReplicate.SetMaxSize( CServiceConfig::GetInstance()->GetMaxQueueSize() );
+
+	// 복제 시도 후 실패한 정보를 관리하는 큐.
+	CDataQueue<CRetryData> queueRetry;
+	queueRetry.SetMaxSize( CServiceConfig::GetInstance()->GetMaxQueueSize() );
+
+	// 복제 완료된 결과를 관리 하는 큐.
+	CDataQueue<CCompleteData> queueComplete;
+	queueComplete.SetMaxSize( CServiceConfig::GetInstance()->GetMaxQueueSize() );
+
+	// Cache 생성 요청 정보 관리 queue
+	CDataQueue<CCacheRequestData> queueCacheRequest;
+	queueCacheRequest.SetMaxSize( CServiceConfig::GetInstance()->GetMaxQueueSize() );
+
+	// Cache 생성 완료 결과 관리 queue
+	CDataQueue<CCacheData> queueCacheComplete;
+	queueCacheComplete.SetMaxSize( CServiceConfig::GetInstance()->GetMaxQueueSize() );
+
+	// Cache 생성 관련 job 정보 관리 객체 생성
+	CCacheJobList objCacheJob;
+
+
+	// 1.2 공통 모듈 생성
+	
+	// 모니터링 및 전체 Thread 갯수 제어 관련 객체 생성	 
+	CProcessStatus objProcessStatus( &queueReplicate, &queueRetry, &queueComplete, &queueCacheRequest, &queueCacheComplete, &objCacheJob );
+	if( objProcessStatus.Init( CServiceConfig::GetInstance()->GetMaxReplicationThread()
+		, CServiceConfig::GetInstance()->GetMaxCacheThread() ) == false )
+	{
+		LOG( LERR, "Worker[%d] process status module Init() failed.", getpid() );
+		return EXIT_FAILURE; // EXIT_FAILURE 를 반환하여 재생성 처리 방지
+	}
+
+	// RCDB 에서 proper FHS 정보를 조회하는 Thread 모듈 생성.
+	CProperFhs objProperFhs;
+	if( objProperFhs.Init() == false )
+	{
+		LOG( LERR, "Worker[%d] proper fhs management module Init() failed.", getpid() );
+		return EXIT_FAILURE; // EXIT_FAILURE 를 반환하여 재생성 처리 방지
+	}
+	
+
+	// 1.3 Replication 관련 모듈 생성
+
+	// replication 에 완료된 content 를 RCDB 에 저장 처리하는 thread 모듈 생성
+	CReplicateInsert objReplicateInsert( &queueComplete );
+	if( objReplicateInsert.Init() == false )
+	{
+		LOG( LERR, "Worker[%d] replication complete insert module Init() failed.", getpid() );
+		return EXIT_FAILURE; // EXIT_FAILURE 를 반환하여 재생성 처리 방지
+	}
+ 	 
+	// RCDB 상에서 replication 대상 content 조회 Thread 모듈 생성
+	CReplicateSelect objReplicateSelect( &queueReplicate );	
+	if( objReplicateSelect.Init() == false )
+	{
+		LOG( LERR, "Worker[%d] replication select module Init() failed.", getpid() );
+		return EXIT_FAILURE; // EXIT_FAILURE 를 반환하여 재생성 처리 방지		
+	}
+
+	// Replication Control Thread 모듈 생성
+	CReplicateControl objReplicateControl( &objProperFhs, &objProcessStatus
+		, &queueReplicate, &queueRetry, &queueComplete );
+	if( objReplicateControl.Init() == false )
+	{
+		LOG( LERR, "Worker[%d] replication control module Init() failed.", getpid() );
+		return EXIT_FAILURE; // EXIT_FAILURE 를 반환하여 재생성 처리 방지
+	}
+		
+	
+	// 1.4 Hot Content Cache 관련 모듈 생성
+	
+	// RCDB 에서 유효기간이 만료된 Cache Content 삭제 Thread 모듈 생성.
+	CCacheDelete objCacheDelete;
+	if( objCacheDelete.Init() == false )
+	{
+		LOG( LERR, "Worker[%d] cache delete module Init() failed.", getpid() );
+		return EXIT_FAILURE; // EXIT_FAILURE 를 반환하여 재생성 처리 방지
+	}
+
+	// 생성된 Cache 완료 정보를 RCDB 에 저장하는 Thread 모듈 생성.
+	CCacheInsert objCacheInsert( &queueCacheComplete, &objCacheJob );
+	if( objCacheInsert.Init() == false )
+	{
+		LOG( LERR, "Worker[%d] cache complete insert module Init() failed.", getpid() );
+		return EXIT_FAILURE; // EXIT_FAILURE 를 반환하여 재생성 처리 방지
+	}
+
+	// Cache 요청을 확인하여 Job 에 등록을 수행하는 Thread 모듈 생성
+	CCacheOrder objCacheOrder( &queueCacheRequest, &objCacheJob, &objProperFhs );
+	if( objCacheOrder.Init() == false )
+	{
+		LOG( LERR, "Worker[%d] cache job order module Init() failed.", getpid() );
+		return EXIT_FAILURE; // EXIT_FAILURE 를 반환하여 재생성 처리 방지
+	}
+	
+	// Cache 생성 처리를 담당하는 Thread 제어 모듈 생성
+	CCacheControl objCacheControl( &objProcessStatus, &objCacheJob, &queueCacheComplete );
+		
+
+	// 2. 각 수행 모듈 기동 처리.
+	//   - 기동 실패시 exit( EXIT_FAILURE ) 또는 return EXIT_FAILURE 를 수행하여
+	//     초기화 실패로 인한 프로세스 종료가 발생토록 한다.
+
+	// 2.1 공통 모듈 기동
+
+	// Process 상태 표시 관련 Thread 기동
+	if( objProcessStatus.Start() == false )
+	{
+		LOG( LERR, "Worker[%d]: Process status module start fail. => Worker Exit", getpid() );
+		return EXIT_FAILURE; // EXIT_FAILURE 를 반환하여 재생성 처리 방지		
+	}
+	_LOG( LINF, "Worker[%d]: CProcessStatus module start.", getpid() );
+	
+	// RCDB 에서 Proper FHS 내역 조회 및 관리 관련 모듈 기동처리.
+	if( objProperFhs.Start() == false )
+	{
+		LOG( LERR, "Worker[%d]: Proper FHS management module start fail. => Worker Exit", getpid() );
+		return EXIT_FAILURE; // EXIT_FAILURE 를 반환하여 재생성 처리 방지		
+	}
+	_LOG( LINF, "Worker[%d]: CProperFhs module start.", getpid() );
+
+	
+	// 2.2 Replication 관련 수행 모듈 기동
+
+	// Replication 완료 content 에 대한 RCDB insert 처리 모듈 기동처리.
+	if( objReplicateInsert.Start() == false )
+	{
+		LOG( LERR, "Worker[%d]: Replicate complete insert module start fail. => Worker Exit", getpid() );
+		return EXIT_FAILURE; // EXIT_FAILURE 를 반환하여 재생성 처리 방지
+	}
+	_LOG( LINF, "Worker[%d]: CCompleteTargetInserter module start.", getpid() );
+	
+	// Replication 대상 content 조회 모듈 기동처리.
+	if( objReplicateSelect.Start( CServiceConfig::GetInstance()->GetTargetSelectInterval()
+		, CServiceConfig::GetInstance()->GetTargetSelectIntervalOnStarting() ) == false )
+	{
+		LOG( LERR, "Worker[%d]: Replicate target selector module start fail. => Worker Exit", getpid() );
+		return EXIT_FAILURE; // EXIT_FAILURE 를 반환하여 재생성 처리 방지		
+	}
+	_LOG( LINF, "Worker[%d]: CReplicateTargetSelector module start.", getpid() );
+			
+	// Replication 생성 관련 제어 모듈 기동처리.
+	if( objReplicateControl.Start() == false )
+	{
+		LOG( LERR, "Worker[%d]: Replication control module start fail. => Worker Exit", getpid() );
+		return EXIT_FAILURE; // EXIT_FAILURE 를 반환하여 재생성 처리 방지		
+	}
+	_LOG( LINF, "Worker[%d]: CReplicateControl module start.", getpid() );
+
+	
+	// 2.3 Hot content cache 관련 수행 모듈 기동
+	
+	// RCDB 에서 유효기간 만료된 Cache Content 삭제 처리 모듈 기동처리.
+	if( objCacheDelete.Start() == false )
+	{
+		LOG( LERR, "Worker[%d]: Cache delete module start fail. => Worker Exit", getpid() );
+		return EXIT_FAILURE; // EXIT_FAILURE 를 반환하여 재생성 처리 방지		
+	}
+	_LOG( LINF, "Worker[%d]: CCacheDelete module start.", getpid() );
+
+	// 생성된 Cache 정보를 RCDB 에 저장하기 위한 모듈 기동 처리
+	if( objCacheInsert.Start() == false )
+	{
+		LOG( LERR, "Worker[%d]: Complete cache insert module start fail. => Worker Exit", getpid() );
+		return EXIT_FAILURE; // EXIT_FAILURE 를 반환하여 재생성 처리 방지		
+	}
+	_LOG( LINF, "Worker[%d]: CCacheInsert module start.", getpid() );
+		
+	// Cache 요청을 확인하여 Job 에 등록을 수행하는 Thread 모듈 기동 처리
+	if( objCacheOrder.Start() == false )
+	{
+		LOG( LERR, "Worker[%d]: Cache job order module start fail. => Worker Exit", getpid() );
+		return EXIT_FAILURE; // EXIT_FAILURE 를 반환하여 재생성 처리 방지		
+	}
+	_LOG( LINF, "Worker[%d]: CCacheOrder module start.", getpid() );
+
+	// Cache 생성 Thread 제어 모듈 기동 처리
+	if( objCacheControl.Start() == false )
+	{
+		LOG( LERR, "Worker[%d]: Cache control module start fail. => Worker Exit", getpid() );
+		return EXIT_FAILURE; // EXIT_FAILURE 를 반환하여 재생성 처리 방지		
+	}
+	_LOG( LINF, "Worker[%d]: CCacheControl module start.", getpid() );
+
+
+	// 모듈 초기화 및 기동 처리 완료.
+	/////////////////////////////////////////////////////////////////////
+	// worker 프로세스의 작업 수행.
+
+	
+	// fimngd 로 부터 hot content 정보를 수신 처리한다.
+	int clientSocket;
+	struct sockaddr_in clientSockAddr;
+	socklen_t clientSockLen = sizeof( clientSockAddr );
+
+	pthread_t clientThreadId;
+	struct stFhsReceiveThreadArg * pThreadArg = NULL;
+
+	while( 1 )
+	{
+		clientSocket = accept( socketListenHotContent, ( struct sockaddr * ) &clientSockAddr, &clientSockLen );
+		if( clientSocket == -1 )
+		{
+			// 오류발생시 해당 내역 로깅처리.
+			int errorNum = errno;
+			LOG( LERR, "Worker: fimngd client accept failed. [%d][%s]", errorNum, strerror( errorNum ) );
+		}
+		else
+		{
+			// 정상적인 Client 인 경우...
+
+			// Thread 로 전달할 변수를 malloc 로 생성 처리
+			pThreadArg = ( struct stFhsReceiveThreadArg * ) malloc( sizeof( struct stFhsReceiveThreadArg ) );
+			if( pThreadArg == NULL )
+			{
+				int errorNum = errno;
+				close( clientSocket );
+				
+				char tempBuffer[INET_ADDRSTRLEN];
+				memset( tempBuffer, 0x00, sizeof( tempBuffer ) );
+				if( inet_ntop( AF_INET, &( clientSockAddr.sin_addr ), tempBuffer, sizeof( tempBuffer ) ) != NULL )
+				{
+					LOG( LERR, "[%s] hot content receive thread malloc failed [%d][%s]", tempBuffer, errorNum, strerror( errorNum ) );
+				}
+				else
+				{
+					LOG( LERR, "hot content receive thread malloc failed [%d][%s] and inet_ntop error[%d][%s]"
+						, errorNum, strerror( errorNum ), errno, strerror( errno ) );
+				}
+
+				continue;
+			}
+			else
+			{
+				// 인자로 전달할 변수정보 설정.
+				pThreadArg->clientSocketDesc   = clientSocket;
+				pThreadArg->pQueueCacheRequest = &queueCacheRequest;
+
+				char tempBuffer[INET_ADDRSTRLEN];
+				memset( tempBuffer, 0x00, sizeof( tempBuffer ) );
+				if( inet_ntop( AF_INET, &( clientSockAddr.sin_addr ), tempBuffer, sizeof( tempBuffer ) ) != NULL )
+				{
+					memcpy( pThreadArg->szClientAddress, tempBuffer, INET_ADDRSTRLEN );
+				}
+				else
+				{
+					snprintf( pThreadArg->szClientAddress, INET_ADDRSTRLEN - 1, "0.0.0.0" );
+				}
+				
+				// fimngd 로부터 hot content 정보를 수신할 Thread 생성 처리
+				if( pthread_create( &clientThreadId, NULL, threadHotContentReceive, (void *)pThreadArg ) != 0 )
+				{
+					// 생성 실패시...
+					// - 로깅 
+					// - client socket close 
+					// - malloc 로 생성된 전달 변수 free 처리.
+
+					int errorNum = errno;
+					LOG( LERR, "[%s] hot content receive thread create failed [%d][%s]"
+						, pThreadArg->szClientAddress, errorNum, strerror( errorNum ) );
+
+					close( clientSocket );
+					free( pThreadArg );
+				}
+			}
+		}
+	} // while( 1 )
+	
+    
+	// Process 종료 처리.
+	_LOG(  LINF, "Worker[%d] exit.. Good Bye..", getpid());
+        
+    //잠시 대기 후 종료처리.
+	
+	// CHG 2015-09-14 huibong
+	// - #24369 usleep -> nanosleep 으로 변경 처리.
+	struct timespec sleep;
+	sleep.tv_sec = 0;
+	sleep.tv_nsec = 500000000;  // 0.5 sec
+	nanosleep( &sleep, NULL );
+
+
+	// fork 를 수행한 함수에서 exit 함수 호출을 통한 종료처리
+	return EXIT_SUCCESS;	
+}
+
+
+// FHS 의 fimngd 로 부터 TCP 연결 요청을 받아...
+// Hot Content 정보를 수신 처리하기 위한 Thread 
+void * threadHotContentReceive( void * arg )
+{
+	// 전달받은 변수를 내부 변수에 저장 처리.
+
+	// client socket 관련 처리 변수 생성	
+	CFimngdSocketControl clientSocket( ( ( struct stFhsReceiveThreadArg * ) arg )->clientSocketDesc );
+	
+	// client 주소 처리 관련 
+	char szClientAddress[INET_ADDRSTRLEN];
+	memcpy( szClientAddress, ( ( struct stFhsReceiveThreadArg * ) arg )->szClientAddress, INET_ADDRSTRLEN );
+
+	// 수신된 정보를 저장하기 위한 queue 에 대한 포인터
+	CDataQueue<CCacheRequestData> * pQueueCacheRequest = ( ( struct stFhsReceiveThreadArg * ) arg )->pQueueCacheRequest;
+		
+	// malloc 로 생성된 변수 해제 처리
+	free( arg );
+
+	// 본 thead 는 client 연결 상태에 따라 종료되므로.. process 에서 분리 처리
+	pthread_detach( pthread_self() );
+
+	_LOG( LDBG, "hot content recieve thread start [%s]", szClientAddress );
+	
+
+	// FHS fimngd 로 부터 data 수신 대기
+	int nRead;
+	CCacheRequestData receiveData;
+
+	while( 1 )
+	{
+		// Data 수신 객체 초기화.
+		receiveData.Init();
+
+		// Data 수신
+		nRead = clientSocket.GetData( receiveData );
+
+		if( nRead == 0 )
+		{
+			// timeout 발생시			
+			// - fimngd 는 data 전송 후.. 추가 전송할 data 가 있는지 일정기간 세션을 유지함.
+			// - 따라서 .. 잠깐 sleep 후.. 다시 수신 시도.한다.
+			sleep( 3 );
+			continue;			
+		}
+		else if( nRead < 0 )
+		{
+			// Socket 오류 발생시
+			// - 관련 로그는 해당 모듈에서 다 찍었으므로.. 여기서는 루프 종료 처리.
+			break;
+		}
+		else
+		{
+			// 정상 Data 수신시 유효 요청인지 검사한다.
+			if( CLogger::GetInstance() != NULL && CLogger::GetInstance()->GetLogLevel() >= LDBG )
+			{
+				receiveData.Print();
+			}
+
+			// 1. RCID 확인
+			if( strcasecmp( receiveData.m_strRcid.c_str(), CServiceConfig::GetInstance()->GetRcId() ) != 0 )
+			{
+				// RCID 가 유효하지 않은 경우..
+				// - 잘못된 세션 요청이므로...  
+				// - 로깅, Report 로깅 후 세션 종료 처리한다.
+				_LOG( LWAR, "cache request: rc id mismatch.[%s][%s]"
+					, receiveData.m_strRcid.c_str()
+					, receiveData.m_strRequestHost.c_str() );
+
+				CReportLog reportLog;
+				if( reportLog.Init( CServiceConfig::GetInstance()->GetLogPath() ) == false )
+				{
+					std::string strErrorMessage;
+					reportLog.GetLastError( strErrorMessage );
+
+					LOG( LERR, "report log init fail. [%s]", strErrorMessage.c_str() );
+				}
+				else
+				{
+					reportLog.Write( "ERR", "[%s][Cache request RC ID mismatch. check FHS[%s][%s]]"
+						, PROG_NAME
+						, receiveData.m_strRequestHost.c_str()
+						, receiveData.m_strRcid.c_str() );
+				}
+
+				// 세션 종료 처리.
+				break;
+			}
+			
+			// 2. filename_hash 정보가 정확한지
+			if( receiveData.m_strFileNameHash.empty() == true )
+			{
+				// filename_hash 정보가 존재하지 않는 경우..
+				// - 현재 수신된 정보는 버리고.. 다시 수신 대기
+				_LOG( LWAR, "cache request: file name empty. [%s]"
+					, receiveData.m_strRequestHost.c_str() );
+
+				// 다시 수신 대기
+				continue;
+			}
+			// 3. szServiceID ( 구 Tran ID 정보) 가 정확한지 검사			
+			if( receiveData.m_strServiceSeq.empty() == true )
+			{
+				// 서비스 ID  정보가 존재하지 않는 경우..
+				// - 현재 수신된 정보는 버리고.. 다시 수신 대기
+				_LOG( LWAR, "cache request: service sequence empty. [%s]"
+					, receiveData.m_strRequestHost.c_str() );
+
+				// 다시 수신 대기
+				continue;
+			}
+
+			
+			// 4. Content Length 값이 0 이상인지....
+			if( receiveData.m_uContentLength == 0 )
+			{
+				_LOG( LWAR, "cache request: content length 0. [%s][%s]"
+					, receiveData.m_strRequestHost.c_str()
+					, receiveData.m_strFileNameHash.c_str() );
+				
+				// 다시 수신 대기
+				continue;
+			}
+
+			// 5. 동접 FD 의 값이 conf 에 설정된 값 이상인지 검사
+			if( receiveData.m_uConcurrentFd < CServiceConfig::GetInstance()->GetHotContentCreateMinimumFd() )
+			{
+				// Cache 생성 요청의 동접 FD 값이 conf 의 설정값 미만인 경우....
+				// - 다음 data 수신 대기
+				_LOG( LDBG, "cache request: fd count lower. ignored. [%u/%u] [%s][%s]"
+					, receiveData.m_uConcurrentFd
+					, CServiceConfig::GetInstance()->GetHotContentCreateMinimumFd()
+					, receiveData.m_strRequestHost.c_str()
+					, receiveData.m_strFileNameHash.c_str() );
+
+				continue;
+			}
+			
+			// 유효 요청인 경우... 
+			// - Queue 에 Push 처리한다.
+			// - 만약 queue 가 full 이라 push 가 실패나는 경우.. 3번 재시도, 안되면 버린다.
+			int nRetry = 0;
+			while( pQueueCacheRequest->Push( receiveData ) == false )
+			{
+				++nRetry;
+
+				if( nRetry > 3 )
+				{
+					_LOG( LWAR, "Cache request push to queue fail. ignored [%s][%s]"
+						, receiveData.m_strRequestHost.c_str()
+						, receiveData.m_strFileNameHash.c_str() );
+
+					break;
+				}
+				else
+				{
+					sleep( 1 );
+				}
+			}
+		}
+	}
+
+	// client 와 연결 종료 처리.
+	_LOG( LDBG, "hot content recieve connection closed.[%s]", szClientAddress );
+
+	clientSocket.Close();
+
+	return NULL;
+}
+
+
+
+/// @brief Worker Process 종료 Signal 을 전달받은 경우 이를 처리하기 위한 함수.
+/// @param nSignalNumber [in] 발생한 시그널 Number
+/// @return void
+static void SignalWorkerTerminate(int nSignalNumber)
+{
+	// Signal Number 에 따른 로깅처리.
+	if( nSignalNumber == SIGTERM )
+	{
+		_LOG( LINF, "Worker[%d] process exit by user signal [SIGTERM]. Good Bye..", getpid() );
+	}
+	else
+	{
+		_LOG( LWAR, "Worker[%d] process exit by abnormal signal[%d], Good Bye..", getpid(), nSignalNumber );
+	}
+
+	// CHG 2015-09-14 huibong
+	// - #24369 usleep -> nanosleep 으로 변경 처리.
+	struct timespec sleep;
+	sleep.tv_sec = 0;
+	sleep.tv_nsec = 500000000;  // 0.5 sec
+	nanosleep( &sleep, NULL );
+	
+
+	exit( EXIT_SUCCESS );
+}
+
+/// @brief Worker 프로세스 signal 처리 설정을 위한 함수	
+/// @return void	
+void SetSignalWorker( void )
+{
+	sigset_t set;
+	struct sigaction act;
+	memset(&act, 0x00, sizeof(act));
+
+	sigfillset( &set );
+	sigprocmask( SIG_SETMASK, &set, NULL );	
+	sigfillset( &act.sa_mask );
+
+	/* 무시할 신호 목록 */
+	act.sa_handler = SIG_IGN;
+	sigaction( SIGPIPE, &act, NULL);	/* desciptor 오류 발생시 Process가 죽는 것은 방지하기 위하여 설정 */
+	sigaction( SIGHUP,  &act, NULL);	/* process를 기동시킨 관리자의 로그아웃시, 또는 config reload 등의 처리 signal*/
+	sigaction( SIGINT,  &act, NULL);	/* ^C 키를 누른 경우 받는 신호 => demon 으로 기동되기 땜시 이 신호 못받음 */
+	sigaction( SIGQUIT, &act, NULL);	/* 키보드에 의한  Abort 신호 처리 => ? */
+	
+	// Worker 프로세스는 자식 프로세스가 존재하지 않으므로 그냥 무시처리함.
+	act.sa_handler = SIG_IGN;
+	sigaction( SIGCHLD, &act, NULL);
+	
+	/* 각종 에러나 사용자의 종료 신호 처리 */
+	act.sa_handler = SignalWorkerTerminate;
+	sigaction( SIGTERM, &act, NULL);	/* kill -TERM 에 의한 프로세스 종료시 */
+
+	sigemptyset(&set);                  /* 신호 처리기 처리 설정 위한 블록 해제 */
+	sigprocmask(SIG_SETMASK, &set, NULL);
+}

rcts/rc_rmcd/src/Worker.h

@@ -0,0 +1,50 @@
+/***************************************************************************
+                    rc_rmcd Worker Header ( Worker.h )
+                -----------------------------------------
+	begin      : 2010/03/09
+	copyright  : (C) 2005 Solbox Inc.
+	author     : Storage Dev Team
+	email      : storage.sd@solbox.com
+	version    : 1.0
+
+	CopyRight(C) 2005 Solbox Inc. All Rights reserved.
+	Redistribution and use in source and binary forms, with or with out
+	modification, are not permitted in outside of Solbox Inc.
+***************************************************************************/
+
+#ifndef __RC_RMCD_WORKER_H__
+#define __RC_RMCD_WORKER_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+	// Worker Process 의 main 함수
+	// @param socketListenHotContent fimngd 로 부터 Hot Content 정보 수신을 위한 TCP Listen socket
+	// @return EXIT_FAILURE 모듈 초기화 실패시
+	//         EXIT_SUCCESS 그 외 정상 종료
+	int WorkerMain( int socketListenHotContent );
+
+	/// @brief Worker 프로세스 signal 처리 설정을 위한 함수	
+	/// @return void	
+	void SetSignalWorker( void );
+	
+
+	// FHS 의 fimngd 로 부터 TCP 연결 요청을 받아...
+	// Hot Content 정보를 수신 처리하기 위한 Thread 
+	void * threadHotContentReceive( void * arg );
+
+
+	/* Signal 처리를 위한 각 Signal Handler 함수는 
+	 * 다른 Code 에서 Include 처리시 Static 관련 문제로 인해 
+	 * 본 Header 에서 선언처리 하지 않음. cpp 에만 존재 
+	 */
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* __RC_RMCD_WORKER_H__ */
+
+