This commit is contained in:
biosvos
2026-08-07 17:38:18 +09:00
commit 873193a243
9613 changed files with 2755992 additions and 0 deletions
+91
View File
@@ -0,0 +1,91 @@
Revision 1534
-------------------
수정일 : 2021-04-19
수정자 : 유희곤
- NEW: content 에 대한 size, atime, mtime, ctime 추출 기능 추가 (#33516)
- stat 함수를 이용하여 content 에 대한 size, access, modify, change time 정보 추출 기능 추가
- 이와 관련 interface 함수도 추가 처리
Revision 1364
-------------------
수정일 : 2016-05-12
수정자 : 유희곤
- NEW: 고객사 토토디스크 지원용 File Check 기능 추가 (#27533)
- 토토디스크 지원 관련 Revision 1358 에서 추가한 MD5 Hash 추출 기능 이외에
- Checksum , DNA CHECK Key 값 추출 관련 ftsd 와 통신 프로토콜 수정 및 전달 기능 추가.
- 수정파일: FtsdSocketControl.h FtsdSocketControl.cpp
- CHG: Client interface 의 Data 수신 Timeout 관련 기능 수정
- 프로토콜 형식이 일치하지 않는 경우... Data 수신 처리시 alive check 로 인한 timeout 처리 미발생.
- 이는 수신 처리 timeout 이 기본 15 sec 인데.. 5 sec 마다 alive check 가 동작하여 timeout 이 미발생함.
- 이를 해결하지 위해 data body 수신 처리시.. timeout 을 2 sec 로 지정 처리함.
- 수정파일: FtsdSocketControl.cpp
Revision 1358
-------------------
수정일 : 2016-05-09
수정자 : 유희곤
- NEW: 고객사 토토디스크 지원용 MD5 Hash 추출관련 프로토콜 및 interface 함수 추가 (#27460)
- 토토디스크 MD5 Hash 추출 관련 통신 CONTROL_FILE_CHECK_TOTO 프로토콜 및 관련 interface 함수 추가
- 토토디스크용 Test 파일 추가.
- 수정 파일: FtsdProtocol.h FtsdSocketControl.h FtsdSocketControl.cpp sample/main_TOTOcheck.cpp
Revision 0811
-------------------
수정일 : 2012-09-04
수정자 : 유희곤
- NEW: 파일에 대한 unlink 처리시 강제 삭제 처리 기능 추가
- unlink 관련 모드 정보를 전달받아 처리하도록 기능 추가함.
- 제어 모듈을 위한 Interface 함수 수정.
- CHG: 수정된 Logger 처리 모듈 적용
- 일감 #10138 에서 수정된 Logger 모듈 (Revision 805) 적용 처리
Revision 0803
-------------------
수정일 : 2012-08-14
수정자 : 유희곤
- NEW: 파일에 대한 Check ( Size, Hash ) 기능 및 인터페이스 추가
- 요청 파일에 대한 존재 여부 확인 및 Size 정보 추출, Hash 정보 추출 기능 추가.
- 제어 모듈을 위한 Interface 함수 추가.
- NEW: 파일에 대한 Unlink 기능 및 인터페이스 추가
- 요청 파일에 대한 unlink 처리 기능 추가
- 제어 모듈을 위한 Interface 함수 추가
- CHG: 양방향 Main 버전 (3.2.0) 변경 사항 적요.
- 기존 3.1.0 -> 3.2.0 으로 버전 변경 처리.
Revision 0668
-------------------
수정일 : 2012-02-07
수정자 : 유희곤
- CHG: Logger 처리 객체 변경 및 관련 코드 수정
- 서비스 1팀 공통 Logger 클래스 ( singleton 방식) 적용 및 관련 코드 수정
- Log 메시지 관련 알아보기 쉽도록 부분 수정 처리.
Revision 0638
-------------------
수정일 : 2011-12-19
수정자 : 유희곤
- NEW: ftsd 사용을 위한 Interface 소스파일 및 샘플 소스 파일을 최초로 SVN 형상에 추가
- ftsd 를 사용하는 Control 프로세스 상에 제공하기 위한 Internface 용 참고 소스 파일 추가 (interface 폴더 )
- ftsd 사용을 위한 Internface 소스 파일에 대한 샘플 소스 제공 ( interface/sample 폴더 )
- 본 변경 사항은 SVN 형상만 변경하였으므로.. 실제 ftsd 버전업은 수행하지 않는다.
+70
View File
@@ -0,0 +1,70 @@
/***************************************************************************
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 처리 요청
// NEW 2016-05-04 huibong 토토디스크 지원용 기능 추가 (#27460)
#define CONTROL_FILE_CHECK_TOTO 0x05 // 토토디스크 고객사 지원을 위한 MD5 Hash 추출 기능 (2016-05-03 추가)
// NEW 2021-04-01 huibong content stat(size, atime, mtime, ctime) 정보 추출 기능 추가 (#33516)
#define CONTROL_FILE_STAT 0x06
// 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__ */
File diff suppressed because it is too large Load Diff
+344
View File
@@ -0,0 +1,344 @@
/***************************************************************************
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 );
// NEW 2016-05-04 huibong 토토디스크 지원용 기능 추가 (#27460)
/// @brief 대상과 연결된 Socket 을 통해 ftsd 로 Content Check 명령 전송. (토토디스크 지원용)
/// @param szFileName [in] 원본 Source 파일명 (/stg/node0/186/abcde..)
/// @return Check 요청 메시지 전송 성공시 true, 실패시 false 반환.
bool SendFileCheckTOTORequest( const std::string& szFileName );
// NEW 2016-05-04 huibong 토토디스크 지원용 기능 추가 (#27460, #27533)
/// @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 szTotoMd5 [out] bSuccess == true 인 경우 추출된 totorasa 용 MD5 Hash 값 정보를 저장.
/// @param szChecksum [out] bSuccess == true 인 경우 추출된 totorasa 용 Checksum 정보를 저장.
/// @param szDnaCheckKey [out] bSuccess == true 인 경우 추출된 totorasa 용 DNA Check key 값 정보를 저장.
/// @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 GetFileCheckTOTOResult( int nTimeout, bool& bSuccess, std::string& szErrorMessage
, unsigned long long& nFileSize, std::string& szTotoMd5, std::string& szChecksum, std::string& szDnaCheckKey );
// NEW 2021-04-01 huibong content stat(size, atime, mtime, ctime) 정보 추출 기능 추가 (#33516)
/// @brief 대상과 연결된 Socket 을 통해 ftsd 로 Content stat 명령 전송.
/// @param szFileName [in] 원본 Source 파일명 (/stg/node0/186/abcde..)
/// @return stat 요청 메시지 전송 성공시 true, 실패시 false 반환.
bool SendFileStatRequest( const std::string & szFileName );
// NEW 2021-04-01 huibong content stat(size, atime, mtime, ctime) 정보 추출 기능 추가 (#33516)
/// @brief File stat 요청에 대한 처리 결과를 ftsd 로 부터 수신한다.
/// @param nTimeout [in] 함수 호출에 대한 Blocking 을 방지하기 위한 Timeout 설정값. 단위( second )\n
///< 지정된 시간동안 응답을 수신하지 못한 경우 0 을 반환.
/// @param bSuccess [out] File Check 처리가 정상적으로 수행되었는지 여부 \n
///< ftsd 상에서 오류가 발생한 경우 이 값은 false 가 되며 \n
///< szErrorMessage 변수상에 오류내용이 저장됨. \n
///< 정상적으로 처리된 경우 true 가 저장되며 \n
///< nFileSize, nAccessTime, nModifyTime, nChangeTime 상에 결과 정보가 저장됨.
/// @param szErrorMessage [out] bSuccess == false 인 경우 발생된 오류메시지 정보를 저장
/// @param nFileSize [out] bSuccess == true 인 경우 요청한 Content 에 대한 file size 정보를 저장. ( Byte 단위 )
/// @param nAccessTime [out] bSuccess == true 인 경우 요청한 Content 에 대한 access time 정보를 저장. ( sec 단위)
/// @param nModifyTime [out] bSuccess == true 인 경우 요청한 Content 에 대한 modify time 정보를 저장. ( sec 단위)
/// @param nChangeTime [out] bSuccess == true 인 경우 요청한 Content 에 대한 change time 정보를 저장. ( sec 단위)
///
/// @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 GetFileStatResult( int nTimeout, bool & bSuccess, std::string & szErrorMessage
, long & nFileSize, long & nAccessTime, long & nModifyTime, long & nChangeTime );
/// @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 );
/// @brief pValue 에 저장된 데이터를 long (64Byte) 형으로 변환처리.
long GetDataToLong( BYTE * pValue );
};
#endif /* __FTSD_SOCKET_CONTROL_H__ */
+64
View File
@@ -0,0 +1,64 @@
#****************************************************************************
# Makefile for ftsd interface sample
# -----------------------------------------
#
# begin : 2010/03/16
# copyright : (C) 2005 SolutionBox Inc.
# author : Service 1 Team
# email : svc1@solbox.com
# version : 3.1..R0668
#
# 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.
#*****************************************************************************
# Program info
PROG_NAME = ftsd_test
# 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 = -D_DEBUG_ -DPROG_NAME=\"$(PROG_NAME)\"
# Enviroment
DIR_INCLUDE = -I./. -I./.. -I./../../lib
DIR_LIB =
#OBJ = ../../lib/Logger.o ../../lib/BaseSocket.o ../FtsdSocketControl.o main_replication.o
#OBJ = ../../lib/Logger.o ../../lib/BaseSocket.o ../FtsdSocketControl.o main_cache.o
#OBJ = ../../lib/Logger.o ../../lib/BaseSocket.o ../FtsdSocketControl.o main_check.o
#OBJ = ../../lib/Logger.o ../../lib/BaseSocket.o ../FtsdSocketControl.o main_unlink.o
#OBJ = ../../lib/Logger.o ../../lib/BaseSocket.o ../FtsdSocketControl.o main_TOTOcheck.o
OBJ = ../../lib/Logger.o ../../lib/BaseSocket.o ../FtsdSocketControl.o main_stat.o
LIBS =
APP = $(PROG_NAME)
############################
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 *.out *.log ./../*.o
-rm -f $(APP)
sync
install : $(APP)
sync
# End of Makefile
@@ -0,0 +1,177 @@
#include <stdlib.h>
#include <string>
#include <map>
#include <iterator>
#include "Logger.h"
#include "FtsdSocketControl.h"
#define LOG_PATH "/user/service/logs" // Log 파일은 /user/service/logs/sample/sample_날짜.log 로 생성됨.
#define TRANSFER_LISTEN_PORT 14001 // ftsd 의 Listen Port
int main( int argc, char * argv[] )
{
std::string szSourceHostName;
std::string szFileName;
if( argc != 3 )
{
///////////// 1. 기본 정보 설정 ///////////////////
// Source 장비 Host Name
//szSourceHostName = "bd-16-fhs001.ktsh.co.kr";
szSourceHostName = "bd-16-fhs003.ktsh.co.kr";
// Source 파일명 ( Mount 위치까지 포함함 전체 경로 )
//szFileName = "/stg/node0/348/4075fac10de1ae95667310cf7e2c9b9a";
//szFileName = "/stg/node0/size0";
//szFileName = "/stg/node0/size256K";
//szFileName = "/stg/node0/size1M";
//szFileName = "/stg/node0/size1M2";
//szFileName = "/stg/node0/size1M3";
//szFileName = "/stg/node0/size4M";
szFileName = "/stg/node0/size10M";
//szFileName = "/stg/node0/size1G";
}
else
{
szSourceHostName = argv[1];
szFileName = argv[2];
}
////////////// 결과값을 저장할 변수 //////////////////
// File Size
unsigned long long nFileSize = 0;
// File 추출값 저장 변수
std::string szTotoMd5;
std::string szChecksum;
std::string szDnaCheckKey;
// 오류 메시지
std::string szErrorMessage;
////////////// Sample 코드 //////////////
// Log 처리용 객체 생성 및 초기화.
if( CLogger::Init( PROG_NAME, LOG_PATH, LDBG ) == false )
{
std::cout << "[error] Logger object created failed.." << std::endl;
return 0;
}
// Start logging
_LOG( LINF, "ftsd check sample Start: Source[%s]", szFileName.c_str());
// ftsd 와 통신을 처리할 Socket Control 객체 생성 및 접속
CFtsdSocketControl ftsdSocket;
if( ftsdSocket.ConnectTarget( szSourceHostName, TRANSFER_LISTEN_PORT ) == false )
{
// Source ftsd 으로 접속 실패시
_LOG( LERR, "Source FHS connect fail. [%s][%d]", szSourceHostName.c_str(), TRANSFER_LISTEN_PORT );
return EXIT_FAILURE;
}
// ftsd 로 TOTO 파일에 대한 Check 요청 전달
// SendFileCheckTOTORequest() 함수는 FtsdSocketControl.h 파일 참조.
if( ftsdSocket.SendFileCheckTOTORequest( szFileName ) == false )
{
// Source ftsd 로 전송 실패시
_LOG( LERR, "Check Request send fail.[%s][%s]", szSourceHostName.c_str(), szFileName.c_str());
return EXIT_FAILURE;
}
// 요청에 대한 응답 대기
int nTimeout = 5; // 응답 대기 시간 ( sec )
int nResult = 0;
bool bResultSuccess; // 처리 결과의 성공/실패 여부를 저장하기 위한 변수.
// 루프를 돌면서 요청에 대한 응답을 대기
while(1)
{
// nTimeout 에 지정된 시간동안 응답대기 시도
// GetFileCheckTOTOResult() 함수는 SocketControl.h 파일 참고.
nResult = ftsdSocket.GetFileCheckTOTOResult( nTimeout, bResultSuccess, szErrorMessage, nFileSize, szTotoMd5, szChecksum, szDnaCheckKey );
if( nResult == -1 )
{
// Socket 통신 관련 오류 또는 접속 종료가 발생한 경우.
// 해당 내역 로깅 및 루프 종료
_LOG( LERR, "ftsd Response wait fail by socket [%s][%s]", szSourceHostName.c_str(), szFileName.c_str() );
break;
}
else if( nResult == 0 )
{
// 지정된 시간 동안 응답대기 중 처리 결과 정보가 아직 수신되지 않은 경우 => Allive Check 패킷 한번 쏘고 다시 Loop 로
if( ftsdSocket.SendAliveCheck() == false )
{
// Alive 전송 실패시 => Socket 종료 및 오류가 발생한 경우임.
_LOG( LERR, "ftsd Response wait fail by socket2 [%s][%s]", szSourceHostName.c_str(), szFileName.c_str() );
break;
}
// 정상적인 경우 다시 응답대기.
continue;
}
else if( nResult == 1 )
{
// 요청에 대한 처리결과 정보가 수신된 경우.
// 해당 정보 로깅처리.
if( bResultSuccess == true )
{
// 요청에 대한 처리가 정상적으로 처리된 경우
//_LOG( LINF, "[%s] Result SUCCESS [%llu][%s]", szFileName.c_str(), nFileSize, szHashValue.c_str());
_LOG( LINF, "TOTO Result size [%llu]", nFileSize );
_LOG( LINF, "TOTO Result md5 hash [%s]", szTotoMd5.c_str());
_LOG( LINF, "TOTO Result checksum [%s]", szChecksum.c_str() );
_LOG( LINF, "TOTO Result dna key [%s]", szDnaCheckKey.c_str() );
}
else
{
// 오류 발생시
_LOG( LINF, "[%s][%s] Result ERROR [%s]", szFileName.c_str(), szSourceHostName.c_str(), szErrorMessage.c_str() );
}
break; // 응답을 받았으니 응답 대기 루프 종료
}
else
{
// Replication 요청에 대한 응답패킷이 아닌 경우.
// 해당 패킷은 무시하고 다시 Loop 로
continue;
}
}
// End logging
_LOG( LINF, "ftsd TOTO check sample process End [%s][%s]", szSourceHostName.c_str(), szFileName.c_str());
_LOG( LINF, "-------------------------------------------------------------------------------" );
CLogger::Exit();
return EXIT_SUCCESS;
}
+179
View File
@@ -0,0 +1,179 @@
#include <stdlib.h>
#include <string>
#include <map>
#include <iterator>
#include "Logger.h"
#include "FtsdSocketControl.h"
#define LOG_PATH "/user/service/logs" // Log 파일은 /user/service/logs/sample/sample_날짜.log 로 생성됨.
#define TRANSFER_LISTEN_PORT 14001 // ftsd 의 Listen Port
int main()
{
///////////// 1. 기본 정보 설정 ///////////////////
// Source 장비 Host Name
std::string szSourceHostName = "bd-16-fhs001.ktsh.co.kr";
// Source 파일명 ( Mount 위치까지 포함함 전체 경로 )
//std::string szSourceFileNameHash = "/stg/node1/186/4b2d62b6357b548ac984894a12630e25";
//std::string szSourceFileNameHash = "/user2/dav_storage/186/00ace1da4678aeb61e7aac6708dcdcaa";
std::string szSourceFileNameHash = "/stg/node0/1/huibong.txt";
// Source 파일의 크기 ( 만약 일치하지 않을 경우 ftsd 에서 오류로 처리함)
//unsigned long long nSourceFileSize = 100000000;
unsigned long long nSourceFileSize = 42;
// Target FHS Host Name 정보 ( 다중 Target 사용 가능으로 인해 vector 사용)
std::vector< std::string > vecTarget;
//vecTarget.push_back( "bd-16-fhs002.ktsh.co.kr" );
//vecTarget.push_back( "bd-16-fhs003.ktsh.co.kr" );
//vecTarget.push_back( "222.122.153.81" );
vecTarget.push_back( "222.122.153.82" );
//vecTarget.push_back( "bd-04-fhs003.ktsh.co.kr" );
//vecTarget.push_back( "bd-04-fhs004.ktsh.co.kr" );
//vecTarget.push_back( "bd-04-fhs005.ktsh.co.kr" );
//vecTarget.push_back( "bd-04-fhs006.ktsh.co.kr" );
///////////// 2. 옵션 설정 //////////////
// 전송완료후 Hash 검사 Level, 0: 안함, 1: 앞뒤 1Mbyte만 검사, 2: 파일 전체검사
int nFileHashCheckLevel = 1;
// 파일 전송시 내부망을 사용할지 여부, RC 내 처리시에는 true 설정, RC-RC 간 동작시에는 효율성을 위해 false 설정할 것.
bool bUseInternalIp = true;
////////////// Sample 코드 //////////////
// Log 처리용 객체 생성 및 초기화.
if( CLogger::Init( PROG_NAME, LOG_PATH, LDBG ) == false )
{
std::cout << "[error] Logger object created failed.." << std::endl;
return 0;
}
// Start logging
_LOG( LINF, "ftsd sample Start: Source[%s][%s][%llu]", szSourceHostName.c_str(), szSourceFileNameHash.c_str(), nSourceFileSize );
// ftsd 와 통신을 처리할 Socket Control 객체 생성 및 접속
CFtsdSocketControl ftsdSocket;
if( ftsdSocket.ConnectTarget( szSourceHostName, TRANSFER_LISTEN_PORT ) == false )
{
// Source ftsd 으로 접속 실패시
_LOG( LERR, "Source FHS connect fail. [%s][%d]", szSourceHostName.c_str(), TRANSFER_LISTEN_PORT );
return EXIT_FAILURE;
}
// Source ftsd 로 파일에 대한 Cache 처리 요청
if( ftsdSocket.SendFileCacheRequest( szSourceFileNameHash, nSourceFileSize, nFileHashCheckLevel, bUseInternalIp, vecTarget ) == false )
{
// Source ftsd 로 Replication 요청 전송 실패시
_LOG( LERR, "Cache Request send fail.[%s][%s][%llu]", szSourceHostName.c_str(), szSourceFileNameHash.c_str(), nSourceFileSize);
return EXIT_FAILURE;
}
// Replication 요청에 대한 응답 대기
int nResult = 0;
int nTimeout = 5; // 응답 대기 시간 ( sec )
bool bResultSuccess; // 처리 결과의 성공/실패 여부를 저장하기 위한 변수.
std::string szResultErrorMessage; // bResultSuccess= fale 인 경우 오류메시지를 저장하기 위한 변수.
std::map< std::string, std::string> mapSuccessInfo; // 성공한 FHS Host명 및 파일정보를 저장하기 위한 list
std::map< std::string, std::string> mapFailInfo; // 실패한 FHS Host명 및 각 FHS별 오류메시지를 저장하기 위한 list
// 루프를 돌면서 Replication 요청에 대한 응답을 대기
while(1)
{
// nTimeout 에 지정된 시간동안 응답대기 시도
nResult = ftsdSocket.GetFileCacheResult( nTimeout, bResultSuccess, szResultErrorMessage, mapSuccessInfo, mapFailInfo );
if( nResult == -1 )
{
// Socket 통신 관련 오류 또는 접속 종료가 발생한 경우.
// 해당 내역 로깅 및 루프 종료
_LOG( LERR, "ftsd Response wait fail by socket [%s][%s]", szSourceHostName.c_str(), szSourceFileNameHash.c_str() );
break;
}
else if( nResult == 0 )
{
// 지정된 시간 동안 응답대기 중 처리 결과 정보가 아직 수신되지 않은 경우 => Allive Check 패킷 한번 쏘고 다시 Loop 로
if( ftsdSocket.SendAliveCheck() == false )
{
// Alive 전송 실패시 => Socket 종료 및 오류가 발생한 경우임.
_LOG( LERR, "ftsd Response wait fail by socket2 [%s][%s]", szSourceHostName.c_str(), szSourceFileNameHash.c_str() );
break;
}
// 정상적인 경우 다시 응답대기.
continue;
}
else if( nResult == 1 )
{
// 요청에 대한 처리결과 정보가 수신된 경우.
// 해당 정보 로깅처리.
if( bResultSuccess == true )
{
// 요청에 대한 처리가 일단은 수행된 경우 => 성공한 FHS 정보 와 실패한 FHS 정보가 나타남.
std::map< std::string, std::string>::const_iterator it;
// 성공한 FHS 목록
for( it = mapSuccessInfo.begin(); it != mapSuccessInfo.end(); it++ )
{
// 성공한 경우 Target FHS Host Name 및 저장된 File Full Name 정보가 표시됨.
_LOG( LINF, "Result SUCCESS [%s][%s]", (it->first).c_str(), (it->second).c_str() );
}
// 실패한 FHS 목록
for( it = mapFailInfo.begin(); it != mapFailInfo.end(); it++ )
{
// 실패한 경우 Target FHS Host Name 및 오류메시지 정보가 표시됨.
_LOG( LINF, "Result FAIL [%s][%s]", (it->first).c_str(), (it->second).c_str() );
}
}
else
{
// 요청에 대한 처리를 아예 수행할 수 없는 경우 => Source FHS 파일 정보 및 각 정보 검사시 오류가 발생한 경우. ( Target FHS 로 접근 작업 전 )
// 인자로 전달한 szResultErrorMessage 상에 오류 발생정보가 저장됨.
_LOG( LINF, "Cache result error [%s][%s][%s]", szSourceHostName.c_str(), szSourceFileNameHash.c_str(), szResultErrorMessage.c_str() );
}
break; // 응답을 받았으니 응답 대기 루프 종료
}
else
{
// Replication 요청에 대한 응답패킷이 아닌 경우.
// 해당 패킷은 무시하고 다시 Loop 로
continue;
}
}
// End logging
_LOG( LINF, "ftsd sample process End [%s][%s][%llu]", szSourceHostName.c_str(), szSourceFileNameHash.c_str(), nSourceFileSize );
_LOG( LINF, "-------------------------------------------------------------------------------" );
CLogger::Exit();
return EXIT_SUCCESS;
}
+166
View File
@@ -0,0 +1,166 @@
#include <stdlib.h>
#include <string>
#include <map>
#include <iterator>
#include "Logger.h"
#include "FtsdSocketControl.h"
#define LOG_PATH "/user/service/logs" // Log 파일은 /user/service/logs/sample/sample_날짜.log 로 생성됨.
#define TRANSFER_LISTEN_PORT 14001 // ftsd 의 Listen Port
int main()
{
///////////// 1. 기본 정보 설정 ///////////////////
// Source 장비 Host Name
//std::string szSourceHostName = "bd-16-fhs001.ktsh.co.kr";
//std::string szSourceHostName = "nh-61-fhs018.x-cdn.com";
std::string szSourceHostName = "nh-61-fhs005.x-cdn.com";
// Source 파일명 ( Mount 위치까지 포함함 전체 경로 )
//std::string szFileName = "/stg/node0/348/d31e2f9043ac62d273c1fd87008a6c86";
//std::string szFileName = "/stg/node0/10m_1";
//std::string szFileName = "/stg/node0/600/2139178cdcacb3ba2a2ca9533bee7fbf";
//std::string szFileName = "/stg/node2/600/616964e59ed7ee956470f88c271cbe68";
//std::string szFileName = "/stg/node0/594/fdd9a1f5b32f062622254fb7c5b4c537";
std::string szFileName = "/stg/node0/594/f962ec80bb5e3257e95925305f6a7296";
// Hash 정보 추출 여부
bool bHashCheck = true;
// Hash 추출 size ( 0 : 전체... 숫자값 : 앞부분부터 지정된 위치의 까지 MByte 단위임 )
//unsigned long long nHashCheckSize = 10;
unsigned long long nHashCheckSize = 0;
////////////// 결과값을 저장할 변수 //////////////////
// File Size
unsigned long long nFileSize = 0;
// Hash 추출값
std::string szHashValue;
// 오류 메시지
std::string szErrorMessage;
////////////// Sample 코드 //////////////
// Log 처리용 객체 생성 및 초기화.
if( CLogger::Init( PROG_NAME, LOG_PATH, LDBG ) == false )
{
std::cout << "[error] Logger object created failed.." << std::endl;
return 0;
}
// Start logging
_LOG( LINF, "ftsd check sample Start: Source[%s]", szFileName.c_str());
// ftsd 와 통신을 처리할 Socket Control 객체 생성 및 접속
CFtsdSocketControl ftsdSocket;
if( ftsdSocket.ConnectTarget( szSourceHostName, TRANSFER_LISTEN_PORT ) == false )
{
// Source ftsd 으로 접속 실패시
_LOG( LERR, "Source FHS connect fail. [%s][%d]", szSourceHostName.c_str(), TRANSFER_LISTEN_PORT );
return EXIT_FAILURE;
}
// ftsd 로 파일에 대한 Check 요청 전달
// SendFileCheckRequest() 함수는 FtsdSocketControl.h 파일 참조.
if( ftsdSocket.SendFileCheckRequest( szFileName, bHashCheck, nHashCheckSize ) == false )
{
// Source ftsd 로 전송 실패시
_LOG( LERR, "Check Request send fail.[%s][%s]", szSourceHostName.c_str(), szFileName.c_str());
return EXIT_FAILURE;
}
// 요청에 대한 응답 대기
int nTimeout = 5; // 응답 대기 시간 ( sec )
int nResult = 0;
bool bResultSuccess; // 처리 결과의 성공/실패 여부를 저장하기 위한 변수.
// 루프를 돌면서 요청에 대한 응답을 대기
while(1)
{
// nTimeout 에 지정된 시간동안 응답대기 시도
// GetFileCheckResult() 함수는 SocketControl.h 파일 참고.
nResult = ftsdSocket.GetFileCheckResult( nTimeout, bResultSuccess, szErrorMessage, nFileSize, szHashValue );
if( nResult == -1 )
{
// Socket 통신 관련 오류 또는 접속 종료가 발생한 경우.
// 해당 내역 로깅 및 루프 종료
_LOG( LERR, "ftsd Response wait fail by socket [%s][%s]", szSourceHostName.c_str(), szFileName.c_str() );
break;
}
else if( nResult == 0 )
{
// 지정된 시간 동안 응답대기 중 처리 결과 정보가 아직 수신되지 않은 경우 => Allive Check 패킷 한번 쏘고 다시 Loop 로
if( ftsdSocket.SendAliveCheck() == false )
{
// Alive 전송 실패시 => Socket 종료 및 오류가 발생한 경우임.
_LOG( LERR, "ftsd Response wait fail by socket2 [%s][%s]", szSourceHostName.c_str(), szFileName.c_str() );
break;
}
// 정상적인 경우 다시 응답대기.
continue;
}
else if( nResult == 1 )
{
// 요청에 대한 처리결과 정보가 수신된 경우.
// 해당 정보 로깅처리.
if( bResultSuccess == true )
{
// 요청에 대한 처리가 정상적으로 처리된 경우
//_LOG( LINF, "[%s] Result SUCCESS [%llu][%s]", szFileName.c_str(), nFileSize, szHashValue.c_str());
_LOG( LINF, "Result size [%llu]", nFileSize );
_LOG( LINF, "Result Hash [%s]", szHashValue.c_str());
}
else
{
// 오류 발생시
_LOG( LINF, "[%s][%s] Result ERROR [%s]", szFileName.c_str(), szSourceHostName.c_str(), szErrorMessage.c_str() );
}
break; // 응답을 받았으니 응답 대기 루프 종료
}
else
{
// Replication 요청에 대한 응답패킷이 아닌 경우.
// 해당 패킷은 무시하고 다시 Loop 로
continue;
}
}
// End logging
_LOG( LINF, "ftsd check sample process End [%s][%s]", szSourceHostName.c_str(), szFileName.c_str());
_LOG( LINF, "-------------------------------------------------------------------------------" );
CLogger::Exit();
return EXIT_SUCCESS;
}
@@ -0,0 +1,181 @@
#include <stdlib.h>
#include <string>
#include <map>
#include <iterator>
#include "Logger.h"
#include "FtsdSocketControl.h"
#define LOG_PATH "/user/service/logs" // Log 파일은 /user/service/logs/sample/sample_날짜.log 로 생성됨.
#define TRANSFER_LISTEN_PORT 14001 // ftsd 의 Listen Port
int main()
{
///////////// 1. 기본 정보 설정 ///////////////////
// Source 장비 Host Name
std::string szSourceHostName = "bd-16-fhs001.ktsh.co.kr";
// Source 파일명 ( Mount 위치까지 포함함 전체 경로 )
//std::string szSourceFileNameHash = "/stg/node1/186/4b2d62b6357b548ac984894a12630e25";
//std::string szSourceFileNameHash = "/user2/dav_storage/186/00ace1da4678aeb61e7aac6708dcdcaa";
std::string szSourceFileNameHash = "/stg/node0/1/huibong.txt";
// Source 파일의 크기 ( 만약 일치하지 않을 경우 ftsd 에서 오류로 처리함)
//unsigned long long nSourceFileSize = 100000000;
unsigned long long nSourceFileSize = 42;
// Target FHS Host Name 정보 ( 다중 Target 사용 가능으로 인해 vector 사용)
std::vector< std::string > vecTarget;
//vecTarget.push_back( "bd-16-fhs002.ktsh.co.kr" );
//vecTarget.push_back( "bd-16-fhs003.ktsh.co.kr" );
//vecTarget.push_back( "222.122.153.81" );
vecTarget.push_back( "222.122.153.82" );
//vecTarget.push_back( "bd-04-fhs003.ktsh.co.kr" );
//vecTarget.push_back( "bd-04-fhs004.ktsh.co.kr" );
//vecTarget.push_back( "bd-04-fhs005.ktsh.co.kr" );
//vecTarget.push_back( "bd-04-fhs006.ktsh.co.kr" );
///////////// 2. 옵션 설정 //////////////
// 전송완료후 Hash 검사 Level, 0: 안함, 1: 앞뒤 1Mbyte만 검사, 2: 파일 전체검사
int nFileHashCheckLevel = 1;
// 파일 전송시 내부망을 사용할지 여부, RC 내 처리시에는 true 설정, RC-RC 간 동작시에는 효율성을 위해 false 설정할 것.
bool bUseInternalIp = true;
////////////// Sample 코드 //////////////
// Log 처리용 객체 생성 및 초기화.
if( CLogger::Init( PROG_NAME, LOG_PATH, LDBG ) == false )
{
std::cout << "[error] Logger object created failed.." << std::endl;
return 0;
}
// Start logging
_LOG( LINF, "ftsd sample Start: Source[%s][%s][%llu]", szSourceHostName.c_str(), szSourceFileNameHash.c_str(), nSourceFileSize );
// ftsd 와 통신을 처리할 Socket Control 객체 생성 및 접속
CFtsdSocketControl ftsdSocket;
if( ftsdSocket.ConnectTarget( szSourceHostName, TRANSFER_LISTEN_PORT ) == false )
{
// Source ftsd 으로 접속 실패시
_LOG( LERR, "Source FHS connect fail. [%s][%d]", szSourceHostName.c_str(), TRANSFER_LISTEN_PORT );
return EXIT_FAILURE;
}
// Source ftsd 로 파일에 대한 Replication 처리 요청
// SendFileReplicationRequest() 함수는 FtsdSocketControl.h 파일 참조.
if( ftsdSocket.SendFileReplicationRequest( szSourceFileNameHash, nSourceFileSize, nFileHashCheckLevel, bUseInternalIp, vecTarget ) == false )
{
// Source ftsd 로 Replication 요청 전송 실패시
_LOG( LERR, "Replication Request send fail.[%s][%s][%llu]", szSourceHostName.c_str(), szSourceFileNameHash.c_str(), nSourceFileSize);
return EXIT_FAILURE;
}
// Replication 요청에 대한 응답 대기
int nResult = 0;
int nTimeout = 5; // 응답 대기 시간 ( sec )
bool bResultSuccess; // 처리 결과의 성공/실패 여부를 저장하기 위한 변수.
std::string szResultErrorMessage; // bResultSuccess= fale 인 경우 오류메시지를 저장하기 위한 변수.
std::map< std::string, std::string> mapSuccessInfo; // 성공한 FHS Host명 및 파일정보를 저장하기 위한 list
std::map< std::string, std::string> mapFailInfo; // 실패한 FHS Host명 및 각 FHS별 오류메시지를 저장하기 위한 list
// 루프를 돌면서 Replication 요청에 대한 응답을 대기
while(1)
{
// nTimeout 에 지정된 시간동안 응답대기 시도
// GetFileReplicationResult() 함수는 SocketControl.h 파일 참고.
nResult = ftsdSocket.GetFileReplicationResult( nTimeout, bResultSuccess, szResultErrorMessage, mapSuccessInfo, mapFailInfo );
if( nResult == -1 )
{
// Socket 통신 관련 오류 또는 접속 종료가 발생한 경우.
// 해당 내역 로깅 및 루프 종료
_LOG( LERR, "ftsd Response wait fail by socket [%s][%s]", szSourceHostName.c_str(), szSourceFileNameHash.c_str() );
break;
}
else if( nResult == 0 )
{
// 지정된 시간 동안 응답대기 중 처리 결과 정보가 아직 수신되지 않은 경우 => Allive Check 패킷 한번 쏘고 다시 Loop 로
if( ftsdSocket.SendAliveCheck() == false )
{
// Alive 전송 실패시 => Socket 종료 및 오류가 발생한 경우임.
_LOG( LERR, "ftsd Response wait fail by socket2 [%s][%s]", szSourceHostName.c_str(), szSourceFileNameHash.c_str() );
break;
}
// 정상적인 경우 다시 응답대기.
continue;
}
else if( nResult == 1 )
{
// 요청에 대한 처리결과 정보가 수신된 경우.
// 해당 정보 로깅처리.
if( bResultSuccess == true )
{
// 요청에 대한 처리가 일단은 수행된 경우 => 성공한 FHS 정보 와 실패한 FHS 정보가 나타남.
std::map< std::string, std::string>::const_iterator it;
// 성공한 FHS 목록
for( it = mapSuccessInfo.begin(); it != mapSuccessInfo.end(); it++ )
{
// 성공한 경우 Target FHS Host Name 및 저장된 File Full Name 정보가 표시됨.
_LOG( LINF, "Result SUCCESS [%s][%s]", (it->first).c_str(), (it->second).c_str() );
}
// 실패한 FHS 목록
for( it = mapFailInfo.begin(); it != mapFailInfo.end(); it++ )
{
// 실패한 경우 Target FHS Host Name 및 오류메시지 정보가 표시됨.
_LOG( LINF, "Result FAIL [%s][%s]", (it->first).c_str(), (it->second).c_str() );
}
}
else
{
// 요청에 대한 처리를 아예 수행할 수 없는 경우 => Source FHS 파일 정보 및 각 정보 검사시 오류가 발생한 경우. ( Target FHS 로 접근 작업 전 )
// 인자로 전달한 szResultErrorMessage 상에 오류 발생정보가 저장됨.
_LOG( LINF, "Replication result error [%s][%s][%s]", szSourceHostName.c_str(), szSourceFileNameHash.c_str(), szResultErrorMessage.c_str() );
}
break; // 응답을 받았으니 응답 대기 루프 종료
}
else
{
// Replication 요청에 대한 응답패킷이 아닌 경우.
// 해당 패킷은 무시하고 다시 Loop 로
continue;
}
}
// End logging
_LOG( LINF, "ftsd sample process End [%s][%s][%llu]", szSourceHostName.c_str(), szSourceFileNameHash.c_str(), nSourceFileSize );
_LOG( LINF, "-------------------------------------------------------------------------------" );
CLogger::Exit();
return EXIT_SUCCESS;
}
+150
View File
@@ -0,0 +1,150 @@
#include <stdlib.h>
#include <string>
#include <map>
#include <iterator>
#include "Logger.h"
#include "../FtsdSocketControl.h"
#define LOG_PATH "/user/service/logs" // Log 파일은 /user/service/logs/sample/sample_날짜.log 로 생성됨.
#define TRANSFER_LISTEN_PORT 14001 // ftsd 의 Listen Port
int main()
{
///////////// 1. 기본 정보 설정 ///////////////////
// Source 장비 Host Name
std::string szSourceHostName = "sb-02-fhs001.solbox.com";
// Source 파일명 ( Mount 위치까지 포함함 전체 경로 )
std::string szFileName = "/stg/node2/66/8bed0cb840eb9a5f2b1eab790e9a3c53";
////////////// 결과값을 저장할 변수 //////////////////
long nFileSize = 0;
long nAccessTime = 0;
long nModifyTime = 0;
long nChangeTime = 0;
// 오류 메시지
std::string szErrorMessage;
////////////// Sample 코드 //////////////
// Log 처리용 객체 생성 및 초기화.
if( CLogger::Init( PROG_NAME, LOG_PATH, LDBG ) == false )
{
std::cout << "[error] Logger object created failed.." << std::endl;
return 0;
}
// Start logging
_LOG( LINF, "ftsd stat sample Start: Source[%s]", szFileName.c_str());
// ftsd 와 통신을 처리할 Socket Control 객체 생성 및 접속
CFtsdSocketControl ftsdSocket;
if( ftsdSocket.ConnectTarget( szSourceHostName, TRANSFER_LISTEN_PORT ) == false )
{
// Source ftsd 으로 접속 실패시
_LOG( LERR, "Source FHS connect fail. [%s][%d]", szSourceHostName.c_str(), TRANSFER_LISTEN_PORT );
return EXIT_FAILURE;
}
// ftsd 로 파일에 대한 stat 요청 전달
// SendFileCheckRequest() 함수는 FtsdSocketControl.h 파일 참조.
if( ftsdSocket.SendFileStatRequest( szFileName) == false )
{
// Source ftsd 로 전송 실패시
_LOG( LERR, "Stat Request send fail.[%s][%s]", szSourceHostName.c_str(), szFileName.c_str());
return EXIT_FAILURE;
}
// 요청에 대한 응답 대기
int nTimeout = 10; // 응답 대기 시간 ( sec )
int nResult = 0;
bool bResultSuccess; // 처리 결과의 성공/실패 여부를 저장하기 위한 변수.
// 루프를 돌면서 요청에 대한 응답을 대기
while(1)
{
// nTimeout 에 지정된 시간동안 응답대기 시도
// GetFileStatResult() 함수는 SocketControl.h 파일 참고.
nResult = ftsdSocket.GetFileStatResult( nTimeout, bResultSuccess, szErrorMessage, nFileSize, nAccessTime, nModifyTime, nChangeTime );
if( nResult == -1 )
{
// Socket 통신 관련 오류 또는 접속 종료가 발생한 경우.
// 해당 내역 로깅 및 루프 종료
_LOG( LERR, "ftsd Response wait fail by socket [%s][%s]", szSourceHostName.c_str(), szFileName.c_str() );
break;
}
else if( nResult == 0 )
{
// 지정된 시간 동안 응답대기 중 처리 결과 정보가 아직 수신되지 않은 경우 => Allive Check 패킷 한번 쏘고 다시 Loop 로
if( ftsdSocket.SendAliveCheck() == false )
{
// Alive 전송 실패시 => Socket 종료 및 오류가 발생한 경우임.
_LOG( LERR, "ftsd Response wait fail by socket2 [%s][%s]", szSourceHostName.c_str(), szFileName.c_str() );
break;
}
// 정상적인 경우 다시 응답대기.
continue;
}
else if( nResult == 1 )
{
// 요청에 대한 처리결과 정보가 수신된 경우.
// 해당 정보 로깅처리.
if( bResultSuccess == true )
{
// 요청에 대한 처리가 정상적으로 처리된 경우
_LOG( LINF, "Result size [%ld] access[%ld] modify[%ld] change[%ld]"
, nFileSize, nAccessTime, nModifyTime, nChangeTime );
}
else
{
// 오류 발생시
_LOG( LINF, "[%s][%s] Result ERROR [%s]", szFileName.c_str(), szSourceHostName.c_str(), szErrorMessage.c_str() );
}
break; // 응답을 받았으니 응답 대기 루프 종료
}
else
{
// Stat 요청에 대한 응답패킷이 아닌 경우.
// 해당 패킷은 무시하고 다시 Loop 로
continue;
}
}
// ftsd socket 종료
ftsdSocket.Close();
// End logging
_LOG( LINF, "ftsd stat sample process End [%s][%s]", szSourceHostName.c_str(), szFileName.c_str());
_LOG( LINF, "-------------------------------------------------------------------------------" );
CLogger::Exit();
return EXIT_SUCCESS;
}
+148
View File
@@ -0,0 +1,148 @@
#include <stdlib.h>
#include <string>
#include <map>
#include <iterator>
#include "Logger.h"
#include "FtsdSocketControl.h"
#define LOG_PATH "/user/service/logs" // Log 파일은 /user/service/logs/sample/sample_날짜.log 로 생성됨.
#define TRANSFER_LISTEN_PORT 14001 // ftsd 의 Listen Port
int main()
{
///////////// 1. 기본 정보 설정 ///////////////////
// Source 장비 Host Name
std::string szSourceHostName = "bd-16-fhs001.ktsh.co.kr";
// Source 파일명 ( Mount 위치까지 포함함 전체 경로 )
//std::string szFileName = "/stg/node0/10m_1.bak";
std::string szFileName = "/stg/node0/huibong.txt";
// File Size
unsigned long long nFileSize = 0;
////////////// 결과값을 저장할 변수 //////////////////
// 오류 메시지
std::string szErrorMessage;
////////////// Sample 코드 //////////////
// Log 처리용 객체 생성 및 초기화.
if( CLogger::Init( PROG_NAME, LOG_PATH, LDBG ) == false )
{
std::cout << "[error] Logger object created failed.." << std::endl;
return 0;
}
// Start logging
_LOG( LINF, "ftsd unlink sample Start: Source[%s]", szFileName.c_str());
// ftsd 와 통신을 처리할 Socket Control 객체 생성 및 접속
CFtsdSocketControl ftsdSocket;
if( ftsdSocket.ConnectTarget( szSourceHostName, TRANSFER_LISTEN_PORT ) == false )
{
// Source ftsd 으로 접속 실패시
_LOG( LERR, "Source FHS connect fail. [%s][%d]", szSourceHostName.c_str(), TRANSFER_LISTEN_PORT );
return EXIT_FAILURE;
}
// ftsd 로 파일에 대한 Check 요청 전달
// SendFileCheckRequest() 함수는 FtsdSocketControl.h 파일 참조.
if( ftsdSocket.SendFileUnlinkRequest( szFileName, nFileSize, true ) == false )
{
// Source ftsd 로 전송 실패시
_LOG( LERR, "Unlink Request send fail.[%s][%s]", szSourceHostName.c_str(), szFileName.c_str());
return EXIT_FAILURE;
}
// 요청에 대한 응답 대기
int nTimeout = 5; // 응답 대기 시간 ( sec )
int nResult = 0;
bool bResultSuccess; // 처리 결과의 성공/실패 여부를 저장하기 위한 변수.
// 루프를 돌면서 요청에 대한 응답을 대기
while(1)
{
// nTimeout 에 지정된 시간동안 응답대기 시도
// GetFileCheckResult() 함수는 SocketControl.h 파일 참고.
nResult = ftsdSocket.GetFileUnlinkResult( nTimeout, bResultSuccess, szErrorMessage);
if( nResult == -1 )
{
// Socket 통신 관련 오류 또는 접속 종료가 발생한 경우.
// 해당 내역 로깅 및 루프 종료
_LOG( LERR, "ftsd Response wait fail by socket [%s][%s]", szSourceHostName.c_str(), szFileName.c_str() );
break;
}
else if( nResult == 0 )
{
// 지정된 시간 동안 응답대기 중 처리 결과 정보가 아직 수신되지 않은 경우 => Allive Check 패킷 한번 쏘고 다시 Loop 로
if( ftsdSocket.SendAliveCheck() == false )
{
// Alive 전송 실패시 => Socket 종료 및 오류가 발생한 경우임.
_LOG( LERR, "ftsd Response wait fail by socket2 [%s][%s]", szSourceHostName.c_str(), szFileName.c_str() );
break;
}
// 정상적인 경우 다시 응답대기.
continue;
}
else if( nResult == 1 )
{
// 요청에 대한 처리결과 정보가 수신된 경우.
// 해당 정보 로깅처리.
if( bResultSuccess == true )
{
// 요청에 대한 처리가 정상적으로 처리된 경우
//_LOG( LINF, "[%s] Result SUCCESS [%llu][%s]", szFileName.c_str(), nFileSize, szHashValue.c_str());
_LOG( LINF, "Unlink result SUCCESS.");
}
else
{
// 오류 발생시
_LOG( LINF, "[%s][%s] Result ERROR (%s)", szFileName.c_str(), szSourceHostName.c_str(), szErrorMessage.c_str() );
}
break; // 응답을 받았으니 응답 대기 루프 종료
}
else
{
// Replication 요청에 대한 응답패킷이 아닌 경우.
// 해당 패킷은 무시하고 다시 Loop 로
continue;
}
}
// End logging
_LOG( LINF, "ftsd check sample process End [%s][%s]", szSourceHostName.c_str(), szFileName.c_str());
_LOG( LINF, "-------------------------------------------------------------------------------" );
CLogger::Exit();
return EXIT_SUCCESS;
}
+12
View File
@@ -0,0 +1,12 @@
#!/bin/sh
CMD="$1"
SLEEP="$2"
while [ 1 ]; do
date
eval $CMD
echo " "
sleep $SLEEP
done