MyService 프로그램 사용법

1. 서비스 관리 명령어

• 주요 기능
• 자동 시작 서비스로 설치됨
• 5초마다 상태 로깅
• Ctrl+C로 디버그 모드 종료 가능
   

   

  # 1. 서비스 설치

  mysvc -i

  # 2. 서비스 시작

  mysvc -r

  # 3. 서비스 중지

  mysvc -s

  # 4. 문제 발생 시 강제 종료

  mysvc -k

  # 5. 서비스 제거

  mysvc -u

   

   

   
• 디버그 모드
• 개발/테스트 시  -d  옵션으로 콘솔에서 직접 실행 가능
• 로그가 콘솔에도 출력됨

#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable: 4819)
#pragma warning(disable: 4100)

#include <windows.h>
#include <tchar.h>
#include <winsvc.h>
#include <iostream>
#include <fstream>
#include <chrono>
#include <ctime>
#include <string>
#include <filesystem>

// 상수 정의
#define SERVICE_NAME _T("MyService")
#define SERVICE_DISPLAY_NAME _T("My Service")
#define SERVICE_DESC _T("My Service Description")
#define LOG_FILE "c:\\mysvc.log"

// 전역 변수
static bool g_debug_mode = false;
static std::ofstream g_log_file;
static SERVICE_STATUS_HANDLE g_ssh = NULL;
static HANDLE g_stop_event = NULL;

// 유니코드 매크로
#ifdef UNICODE
#define tprintf wprintf
#define tstring std::wstring
#else
#define tprintf printf
#define tstring std::string
#endif

// 함수 선언
void MySetStatus(DWORD dstatus, DWORD daccept);
void ServiceHandler(DWORD dwcontrol);
void ServiceHandlerEx(DWORD dwcontrol, DWORD dweventtype, LPVOID lpeventdata, LPVOID lpcontext);
void ServiceMain();
VOID WINAPI ServiceMainProc(DWORD argc, LPTSTR* argv);
bool InstallService();
bool UninstallService();
BOOL MyStartService(tstring Name);
bool StopService();
BOOL WINAPI DebugConsoleHandler(DWORD signal);
bool KillService();

// 로깅 함수
void LogMessage(const std::string& message) {
    auto now = std::chrono::system_clock::now();
    auto time = std::chrono::system_clock::to_time_t(now);
    std::string timestamp = std::ctime(&time);
    timestamp.pop_back();

    std::string formatted_msg = "[" + timestamp + "] " + message + "\n";

    if (g_debug_mode) {
        std::cout << formatted_msg;
    }
    
    if (g_log_file.is_open()) {
        g_log_file << formatted_msg;
        g_log_file.flush();
    }
}

// 서비스 상태 관리 함수
void MySetStatus(DWORD dstatus, DWORD daccept) {
    SERVICE_STATUS ss = { 0, };
    if (!g_ssh) {
        LogMessage("MySetStatus: ERR status handle is null!");
        return;
    }
    ss.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
    ss.dwCurrentState = dstatus;
    ss.dwControlsAccepted = daccept;
    ss.dwWin32ExitCode = 10 * 1000;
    SetServiceStatus(g_ssh, &ss);
}

// 서비스 이벤트 핸들러
void ServiceHandler(DWORD dwcontrol) {
    LogMessage("ServiceHandler: control=" + std::to_string(dwcontrol));
    switch (dwcontrol) {
    case SERVICE_CONTROL_STOP:
        LogMessage("SERVICE_CONTROL_STOP received");
        MySetStatus(SERVICE_STOP_PENDING, SERVICE_ACCEPT_STOP);
        SetEvent(g_stop_event);
        break;
    default:
        MySetStatus(dwcontrol, SERVICE_ACCEPT_STOP);
        break;
    }
}

void ServiceHandlerEx(DWORD dwcontrol, DWORD dweventtype, LPVOID lpeventdata, LPVOID lpcontext) {
    LogMessage("ServiceHandlerEx: control=" + std::to_string(dwcontrol));
    switch (dwcontrol) {
    case SERVICE_CONTROL_SESSIONCHANGE:
        LogMessage("ServiceHandlerEx: session change");
        break;
    default:
        ServiceHandler(dwcontrol);
        break;
    }
}

// 서비스 메인 함수
void ServiceMain() {
    while (WaitForSingleObject(g_stop_event, 500) == WAIT_TIMEOUT) {
        LogMessage("Service is running...");
    }

    LogMessage("ServiceMain: End");
    if (!g_debug_mode) {
        MySetStatus(SERVICE_STOPPED, 0);
    }

    if (g_debug_mode) {
        CloseHandle(g_stop_event);
    }
}

VOID WINAPI ServiceMainProc(DWORD argc, LPTSTR* argv) {
    g_log_file.open(LOG_FILE, std::ios::app);
    LogMessage("Service started");

    g_ssh = RegisterServiceCtrlHandlerEx(SERVICE_NAME, (LPHANDLER_FUNCTION_EX)ServiceHandlerEx, NULL);
    LogMessage("ServiceMainProc: g_ssh=" + std::to_string((uint64_t)g_ssh));
    if (!g_ssh) {
        LogMessage("Failed to register service control handler");
        g_log_file.close();
        return;
    }

    MySetStatus(SERVICE_START_PENDING, 0);

    if (!g_stop_event) {
        g_stop_event = CreateEvent(NULL, TRUE, FALSE, NULL);
        if (!g_stop_event) {
            MySetStatus(SERVICE_STOPPED, 0);
            g_log_file.close();
            return;
        }
    }

    MySetStatus(SERVICE_RUNNING, SERVICE_ACCEPT_STOP);
    ServiceMain();
    g_log_file.close();
}

// 서비스 관리 함수들
bool InstallService() {
    SC_HANDLE scm = OpenSCManager(NULL, NULL, SC_MANAGER_CREATE_SERVICE);
    if (!scm) return false;

    TCHAR path[MAX_PATH];
    GetModuleFileName(NULL, path, MAX_PATH);
    _tcscat_s(path, _T(" -svc"));

    SC_HANDLE service = CreateService(
        scm, SERVICE_NAME, SERVICE_DISPLAY_NAME,
        SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS,
        SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, path,
        NULL, NULL, NULL, NULL, NULL);

    if (service) {
        SERVICE_DESCRIPTION sd = {const_cast<LPTSTR>(SERVICE_DESC)};
        ChangeServiceConfig2(service, SERVICE_CONFIG_DESCRIPTION, &sd);
        CloseServiceHandle(service);
    }
    CloseServiceHandle(scm);
    return service != NULL;
}

bool UninstallService() {
    SC_HANDLE scm = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
    if (!scm) return false;

    SC_HANDLE service = OpenService(scm, SERVICE_NAME, SERVICE_ALL_ACCESS);
    if (!service) {
        CloseServiceHandle(scm);
        return false;
    }

    SERVICE_STATUS status;
    ControlService(service, SERVICE_CONTROL_STOP, &status);
    bool result = DeleteService(service);

    CloseServiceHandle(service);
    CloseServiceHandle(scm);
    return result;
}

BOOL MyStartService(tstring Name) {
    SC_HANDLE schSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
    if (!schSCManager) {
        DWORD err = GetLastError();
        LogMessage("OpenSCManager failed. Error: " + std::to_string(err));
        return FALSE;
    }

    SC_HANDLE schService = OpenService(schSCManager, Name.c_str(), SERVICE_START | SERVICE_QUERY_STATUS);
    if (!schService) {
        DWORD err = GetLastError();
        LogMessage("OpenService failed. Error: " + std::to_string(err));
        CloseServiceHandle(schSCManager);
        return FALSE;
    }

    // 서비스 상태 확인
    SERVICE_STATUS status;
    if (QueryServiceStatus(schService, &status)) {
        if (status.dwCurrentState == SERVICE_RUNNING) {
            LogMessage("Service is already running");
            CloseServiceHandle(schService);
            CloseServiceHandle(schSCManager);
            return TRUE;
        }
    }

    // 서비스 시작
    if (!StartService(schService, 0, NULL)) {
        DWORD err = GetLastError();
        if (err == ERROR_SERVICE_ALREADY_RUNNING) {
            LogMessage("Service is already running");
            CloseServiceHandle(schService);
            CloseServiceHandle(schSCManager);
            return TRUE;
        }
        LogMessage("StartService failed. Error: " + std::to_string(err));
        CloseServiceHandle(schService);
        CloseServiceHandle(schSCManager);
        return FALSE;
    }

    // 서비스가 실제로 시작될 때까지 대기
    int retries = 0;
    while (retries < 10) {  // 최대 10초 대기
        if (QueryServiceStatus(schService, &status)) {
            if (status.dwCurrentState == SERVICE_RUNNING) {
                LogMessage("Service started successfully");
                CloseServiceHandle(schService);
                CloseServiceHandle(schSCManager);
                return TRUE;
            }
            if (status.dwCurrentState == SERVICE_STOPPED) {
                LogMessage("Service failed to start");
                break;
            }
        }
        Sleep(1000);
        retries++;
    }

    CloseServiceHandle(schService);
    CloseServiceHandle(schSCManager);
    return FALSE;
}

bool StopService() {
    SC_HANDLE scm = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
    if (!scm) return false;

    SC_HANDLE service = OpenService(scm, SERVICE_NAME, SERVICE_STOP | SERVICE_QUERY_STATUS);
    if (!service) {
        CloseServiceHandle(scm);
        return false;
    }

    SERVICE_STATUS status;
    bool result = ControlService(service, SERVICE_CONTROL_STOP, &status);
    
    // 서비스가 완전히 중지될 때까지 대기
    if (result) {
        while (QueryServiceStatus(service, &status)) {
            if (status.dwCurrentState == SERVICE_STOPPED) {
                break;
            }
            Sleep(1000);
        }
    }

    CloseServiceHandle(service);
    CloseServiceHandle(scm);
    return result;
}

// 디버그 모드 핸들러
BOOL WINAPI DebugConsoleHandler(DWORD signal) {
    if (signal == CTRL_C_EVENT || signal == CTRL_BREAK_EVENT) {
        LogMessage("Debug mode stop requested");
        if (g_stop_event) {
            SetEvent(g_stop_event);
        }
        return TRUE;
    }
    return FALSE;
}

// 서비스 강제 종료 함수 구현
bool KillService() {
    SC_HANDLE scm = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
    if (!scm) {
        LogMessage("OpenSCManager failed in KillService");
        return false;
    }

    SC_HANDLE service = OpenService(scm, SERVICE_NAME, SERVICE_ALL_ACCESS);
    if (!service) {
        LogMessage("OpenService failed in KillService");
        CloseServiceHandle(scm);
        return false;
    }

    // 현재 서비스 상태 확인
    SERVICE_STATUS status = { 0 };
    if (!QueryServiceStatus(service, &status)) {
        LogMessage("QueryServiceStatus failed in KillService");
        CloseServiceHandle(service);
        CloseServiceHandle(scm);
        return false;
    }

    // 서비스가 이미 중지 상태면 종료
    if (status.dwCurrentState == SERVICE_STOPPED) {
        LogMessage("Service is already stopped");
        CloseServiceHandle(service);
        CloseServiceHandle(scm);
        return true;
    }

    // 서비스 강제 종료 후 상태를 STOPPED로 변경
    LogMessage("Forcing service to stop state");
    memset(&status, 0, sizeof(SERVICE_STATUS));
    status.dwCurrentState = SERVICE_STOPPED;
    ControlService(service, SERVICE_CONTROL_STOP, &status);

    CloseServiceHandle(service);
    CloseServiceHandle(scm);
    return true;
}

// 메인 함수
int main(int argc, char* argv[]) {
    if (argc > 1) {
        if (strcmp(argv[1], "-i") == 0) {
            return InstallService() ? 0 : 1;
        }
        else if (strcmp(argv[1], "-r") == 0) {
            return MyStartService(SERVICE_NAME) ? 0 : 1;
        }
        else if (strcmp(argv[1], "-s") == 0) {
            return StopService() ? 0 : 1;
        }
        else if (strcmp(argv[1], "-u") == 0) {
            return UninstallService() ? 0 : 1;
        }
        else if (strcmp(argv[1], "-d") == 0) {
            g_debug_mode = true;
            SetConsoleCtrlHandler(DebugConsoleHandler, TRUE);
            g_log_file.open(LOG_FILE, std::ios::app);
            LogMessage("Debug mode started");

            g_stop_event = CreateEvent(NULL, TRUE, FALSE, NULL);
            if (!g_stop_event) {
                g_log_file.close();
                return 1;
            }
            ServiceMain();
            g_log_file.close();
            return 0;
        }
        else if (strcmp(argv[1], "-svc") == 0) {
            SERVICE_TABLE_ENTRY serviceTable[] = {
                {const_cast<LPTSTR>(SERVICE_NAME), ServiceMainProc},
                {NULL, NULL}
            };
            return StartServiceCtrlDispatcher(serviceTable) ? 0 : 1;
        }
        else if (strcmp(argv[1], "-k") == 0) {
            return KillService() ? 0 : 1;
        }
    }
    return 0;
}

- 클라이언트 접속이 많은 경우, 부하 조정.  쓰레드 풀을 만들어 성능 관리. 동시 실행 쓰레드 수를 제한하여 시스템 과부하 방지.

- 쓰레드 생성 오버헤드 제거. 동시 접속자수 제한으로 서버 안정성 확보. 쓰레드 풀 크기 조정을 하여 성능 조정.

- ^C로 종료.

#include <iostream>
#include <thread>
#include <vector>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <WinSock2.h>
#include <WS2tcpip.h>
#include <windows.h>
#include <string>
#include <sstream>
#include <atomic>
#include <csignal>
#include <chrono>

#pragma comment(lib, "ws2_32.lib")

#define SERVER_PORT 30000
#define BUFFER_SIZE 1024

#define MAX_THREADS 5           // 최대 스레드 수; CPU 코어 수 만큼 설정
#define MAX_QUEUE_SIZE 500     // 최대 큐 크기. 대기 클라이언트 수 만큼 설정.
#define MAX_CONNECTIONS (MAX_QUEUE_SIZE+MAX_THREADS+10)   // 최대 연결 수

#define SOCKET_TIMEOUT 3000    // 소켓 connect 타임아웃 (밀리초)
#define IDLE_TIMEOUT 10000  // 클라이언트 유휴 타임아웃 (밀리초)


// 디버그 및 에러 로그 매크로 정의
static bool g_debug_mode = false;
static bool g_error_mode = false;
static bool g_info_mode = true;

#define DEBUG_LOG(msg) \
    if (g_debug_mode) { \
        std::stringstream ss; \
        ss << "[DEBUG] " << msg; \
        std::cout << ss.str() << std::endl; \
    }

#define ERROR_LOG(msg) \
    if (g_error_mode) { \
        std::stringstream ss; \
        ss << "[ERROR] " << msg; \
        std::cerr << ss.str() << std::endl; \
    }

#define INFO_LOG(msg) \
    if (g_info_mode) { \
        std::stringstream ss; \
        ss << "[INFO] " << msg; \
        std::cout << ss.str() << std::endl; \
    }

// 전역 변수
static std::atomic<size_t> g_total_requests{0};
static size_t g_last_printed_count{0};
static std::chrono::steady_clock::time_point g_last_print_time;
static SOCKET g_serverSocket = INVALID_SOCKET;

class ThreadPool {
public:
    std::atomic<size_t> current_connections{0};  // 현재 총 연결 수
    std::atomic<size_t> active_threads{0};       // 현재 작업 중인 스레드 수

    size_t GetQueueSize() {
        std::lock_guard<std::mutex> lock(queue_mutex);
        return tasks.size();  // 대기 큐에 있는 클라이언트 수
    }

private:
    std::vector<std::thread> workers;
    std::queue<std::pair<SOCKET, sockaddr_in>> tasks;
    std::mutex queue_mutex;
    std::condition_variable condition;
    std::atomic<bool> stop{false};

    void HandleClient(SOCKET clientSocket, sockaddr_in clientAddr) {
        active_threads++;  // 작업 시작
        try {
            // 소켓 타임아웃 설정
            struct timeval timeout;
            timeout.tv_sec = IDLE_TIMEOUT / 1000;
            timeout.tv_usec = (IDLE_TIMEOUT % 1000) * 1000;
            
            if (setsockopt(clientSocket, SOL_SOCKET, SO_RCVTIMEO, (char*)&timeout, sizeof(timeout)) < 0) {
                ERROR_LOG("Failed to set receive timeout");
            }
            if (setsockopt(clientSocket, SOL_SOCKET, SO_SNDTIMEO, (char*)&timeout, sizeof(timeout)) < 0) {
                ERROR_LOG("Failed to set send timeout");
            }

            char buffer[BUFFER_SIZE];
            char clientIP[INET_ADDRSTRLEN];
            inet_ntop(AF_INET, &clientAddr.sin_addr, clientIP, INET_ADDRSTRLEN);
            
            DEBUG_LOG("Client connected - IP: " << clientIP 
                      << ", Port: " << ntohs(clientAddr.sin_port));

            int bytesReceived = recv(clientSocket, buffer, BUFFER_SIZE, 0);
            if (bytesReceived == SOCKET_ERROR) {
                if (WSAGetLastError() == WSAETIMEDOUT) {
                    ERROR_LOG("Client " << clientIP << " timed out");
                } else {
                    ERROR_LOG("Receive error from " << clientIP);
                }
            } else if (bytesReceived > 0) {
                buffer[bytesReceived] = '\0';
                DEBUG_LOG("Received from " << clientIP << ": " << buffer);

                // 요청 처리 카운터 증가
                g_total_requests.fetch_add(1, std::memory_order_relaxed);

                std::string response;
                if (strcmp(buffer, "sysinfo") == 0) {
                    SYSTEM_INFO sysInfo;
                    GetSystemInfo(&sysInfo);
                    response = "Processor count: " + std::to_string(sysInfo.dwNumberOfProcessors);
                }
                else if (strcmp(buffer, "netinfo") == 0) {
                    char hostname[256];
                    gethostname(hostname, sizeof(hostname));
                    response = "Hostname: " + std::string(hostname);
                }
                else if (strcmp(buffer, "diskinfo") == 0) {
                    DWORD sectorsPerCluster, bytesPerSector, freeClusters, totalClusters;
                    GetDiskFreeSpace(NULL, &sectorsPerCluster, &bytesPerSector, 
                                    &freeClusters, &totalClusters);
                    response = "Disk total space: " + 
                              std::to_string((double)totalClusters * sectorsPerCluster * 
                                           bytesPerSector / (1024 * 1024 * 1024)) + " GB";
                }
                else {
                    response = "Unknown command";
                }

                send(clientSocket, response.c_str(), response.length(), 0);
            }

            DEBUG_LOG("Client disconnected - IP: " << clientIP);
        } catch (const std::exception& e) {
            ERROR_LOG("Exception in HandleClient: " << e.what());
        }
        
        closesocket(clientSocket);
        current_connections--;
        active_threads--;  // 작업 완료
    }

public:
    ~ThreadPool() {
        Shutdown();
    }

    void Shutdown() {
        DEBUG_LOG("ThreadPool shutdown initiated");
        
        stop = true;
        condition.notify_all();

        // 스레드 종료 대기 시작 시간 기록
        auto start = std::chrono::steady_clock::now();
        bool timeout = false;

        // worker 스레드들의 종료를 기다림
        for (std::thread& worker : workers) {
            if (worker.joinable()) {
                try {
                    // 현재 경과 시간 체크
                    auto now = std::chrono::steady_clock::now();
                    auto elapsed = std::chrono::duration_cast<std::chrono::seconds>(now - start).count();
                    if (elapsed >= 3) {  // 3초 초과
                        timeout = true;
                        break;
                    }

                    // 남은 시간만큼만 대기
                    worker.join();
                } catch (const std::exception& e) {
                    ERROR_LOG("Thread join error: " << e.what());
                }
            }
        }

        if (timeout) {
            ERROR_LOG("Thread shutdown timeout - forcing termination");
            // 남은 스레드들을 강제 분리
            for (std::thread& worker : workers) {
                if (worker.joinable()) {
                    worker.detach();
                }
            }
        }
        // 남은 작업들의 소켓을 정리
        std::unique_lock<std::mutex> lock(queue_mutex);
        while (!tasks.empty()) {
            auto& task = tasks.front();
            closesocket(task.first);
            tasks.pop();
        }
        current_connections = 0;
        DEBUG_LOG("ThreadPool shutdown completed");
    }

    // worker 스레드 로직 수정
    ThreadPool() {
        for (int i = 0; i < MAX_THREADS; ++i) {
            workers.emplace_back([this] {
                while (true) {
                    std::pair<SOCKET, sockaddr_in> task;
                    {
                        std::unique_lock<std::mutex> lock(queue_mutex);
                        condition.wait(lock, [this] { 
                            return stop || !tasks.empty(); 
                        });
                        
                        if (stop && tasks.empty()) {
                            DEBUG_LOG("Worker thread exiting");
                            return;
                        }
                        
                        if (!tasks.empty()) {
                            task = std::move(tasks.front());
                            tasks.pop();
                        }
                    }
                    
                    if (task.first != INVALID_SOCKET) {
                        HandleClient(task.first, task.second);
                    }
                }
            });
        }
    }

    bool EnqueueClient(SOCKET clientSocket, sockaddr_in clientAddr) {
        if (current_connections >= MAX_CONNECTIONS) {
            ERROR_LOG("Maximum connections reached");
            closesocket(clientSocket);
            return false;
        }
        current_connections++;

        std::unique_lock<std::mutex> lock(queue_mutex);
        
        if (tasks.size() >= MAX_QUEUE_SIZE) {
            char clientIP[INET_ADDRSTRLEN];
            inet_ntop(AF_INET, &clientAddr.sin_addr, clientIP, INET_ADDRSTRLEN);
            ERROR_LOG("Queue is full. Connection rejected from " << clientIP 
                     << ":" << ntohs(clientAddr.sin_port));
            closesocket(clientSocket);
            current_connections--;  // 연결 거부 시 카운터 감소
            return false;
        }

        tasks.push({clientSocket, clientAddr});
        lock.unlock();
        condition.notify_one();
        return true;
    }
};


// ThreadPool 클래스 전방 선언
class ThreadPool;
static ThreadPool* g_threadPool = nullptr;
static std::atomic<bool> g_running{true};

// 모니터링 함수
void MonitorRequests() {
    while (true) {
        std::this_thread::sleep_for(std::chrono::seconds(5));
        
        if (g_threadPool != nullptr) {
            size_t current_count = g_total_requests.load();
            size_t current_conns = g_threadPool->current_connections.load();
            size_t active_threads = g_threadPool->active_threads.load();
            size_t waiting_clients = g_threadPool->GetQueueSize();

            INFO_LOG("Server Status:"
                    "\n    Total requests processed: " << current_count <<
                    "\n    Current connections: " << current_conns <<
                    "\n    Active threads: " << active_threads << "/" << MAX_THREADS <<
                    "\n    Waiting clients: " << waiting_clients);
        }
    }
}



void SignalHandler(int signal) {
    static std::atomic<bool> shutting_down{false};
    if (shutting_down.exchange(true)) {
        return;
    }
    INFO_LOG("Signal " << signal << " received. Shutting down...");
    g_running = false;
    try {
        if (g_threadPool) {
            g_threadPool->Shutdown();
            // delete g_threadPool;
            g_threadPool = nullptr;
        }
    } catch (const std::exception& e) {
        ERROR_LOG("Exception in SignalHandler: " << e.what());
    }

    if (g_serverSocket != INVALID_SOCKET) {
        closesocket(g_serverSocket);
        g_serverSocket = INVALID_SOCKET;
    }

    WSACleanup();
    std::exit(0);
}

void GracefulShutdown() {
    INFO_LOG("Initiating graceful shutdown");
    g_running = false;
    
    // 새로운 연결 거부
    if (g_serverSocket != INVALID_SOCKET) {
        shutdown(g_serverSocket, SD_BOTH);
        closesocket(g_serverSocket);
    }
}

int main() {
    signal(SIGINT, SignalHandler);
    signal(SIGTERM, SignalHandler);
    // 디버그 모드 설정 (환경변수나 커맨드 라인 인자로도 설정 가능)
    g_debug_mode = false;  // 또는 true

    WSADATA wsaData;
    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
        ERROR_LOG("WSAStartup failed");
        return 1;
    }

    SOCKET serverSocket = socket(AF_INET, SOCK_STREAM, 0);
    g_serverSocket = serverSocket;  // 전역 변수에 저장

    int reuseAddr = 1; // 소켓 재사용 허용
    setsockopt(serverSocket, SOL_SOCKET, SO_REUSEADDR, 
               (const char*)&reuseAddr, sizeof(reuseAddr));

    struct linger lin;
    lin.l_onoff = 1;
    lin.l_linger = 0;  // 즉시 종료, TIME_WAIT 상태 방지
    setsockopt(serverSocket, SOL_SOCKET, SO_LINGER, 
               (const char*)&lin, sizeof(lin));

    sockaddr_in serverAddr;
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(SERVER_PORT);
    serverAddr.sin_addr.s_addr = INADDR_ANY;

    if (bind(serverSocket, (sockaddr*)&serverAddr, sizeof(serverAddr)) == SOCKET_ERROR) {
        ERROR_LOG("Bind failed");
        closesocket(serverSocket);
        WSACleanup();
        return 1;
    }

    if (listen(serverSocket, SOMAXCONN) == SOCKET_ERROR) {
        ERROR_LOG("Listen failed");
        closesocket(serverSocket);
        WSACleanup();
        return 1;
    }

    // 타임아웃 설정
    struct timeval timeout;
    timeout.tv_sec = SOCKET_TIMEOUT / 1000;  // 초 단위
    timeout.tv_usec = (SOCKET_TIMEOUT % 1000) * 1000;  // 마이크로초 단위
    setsockopt(serverSocket, SOL_SOCKET, SO_RCVTIMEO, (char*)&timeout, sizeof(timeout));
    setsockopt(serverSocket, SOL_SOCKET, SO_SNDTIMEO, (char*)&timeout, sizeof(timeout));

    // 모니터링 스레드 시작
    g_last_print_time = std::chrono::steady_clock::now();
    std::thread monitor_thread(MonitorRequests);
    monitor_thread.detach();  // 메인 스레드와 분리

    INFO_LOG("Server started on port " << SERVER_PORT);

    ThreadPool pool;
    g_threadPool = &pool;  // 전역 변수에 저장

    while (g_running) {
        sockaddr_in clientAddr;
        int clientAddrSize = sizeof(clientAddr);
        SOCKET clientSocket = accept(serverSocket, (sockaddr*)&clientAddr, &clientAddrSize);
        
        if (clientSocket == INVALID_SOCKET) {
            if (!g_running) break;  // 정상적인 종료 상황
            ERROR_LOG("Accept failed");
            continue;
        }

        if (!pool.EnqueueClient(clientSocket, clientAddr)) {
            char clientIP[INET_ADDRSTRLEN];
            inet_ntop(AF_INET, &clientAddr.sin_addr, clientIP, INET_ADDRSTRLEN);
            ERROR_LOG("Connection rejected from " << clientIP 
                     << ":" << ntohs(clientAddr.sin_port));
        }
    }
    INFO_LOG("Server end.");
    // 정상 종료 처리
    closesocket(serverSocket);
    WSACleanup();
    return 0;
}

client의 요청이 많을 때 동시접근 및 부하를 해결하기 위한 방안...

- 작업 중이면, 캐시 떠 놓은거 사용. 즉, 빠른 응답이 가능하도록. 

- read lock, write lock 으로 구분. read 작업은 동시 접근 가능. 

#include <iostream>
#include <vector>
#include <shared_mutex>
#include <optional>
#include <thread>
#include <chrono>
#include <atomic>
#include <string>
#include <windows.h>
#include <tlhelp32.h>

// 가정: PROCESS_INFO 구조체
struct PROCESS_INFO {
    int pid;
    std::string name;
};

std::vector<PROCESS_INFO> g_process;                      // 프로세스 목록
std::optional<std::vector<PROCESS_INFO>> g_process_cache; // 캐시된 프로세스 목록
std::shared_mutex process_mutex;                          // 동기화 도구
std::atomic<bool> is_updating{false};  // 업데이트 중인지 확인하는 플래그 추가

// 프로세스 목록을 갱신하는 함수
void update_process(int id) {
    if (is_updating.exchange(true)) {
        std::cout << "Update already in progress, skipping. :  thread id=" << id << "\n";
        return;
    }
    std::cout << "Update processing. :  thread id=" << id << "\n";

    std::vector<PROCESS_INFO> updated_process;
    
    // 프로세스 스냅샷 생성
    HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (snapshot != INVALID_HANDLE_VALUE) {
        PROCESSENTRY32W pe32;
        pe32.dwSize = sizeof(pe32);

        // 첫번째 프로세스 정보 가져오기
        if (Process32FirstW(snapshot, &pe32)) {
            do {
                // 와이드 문자열을 일반 문자열로 변환
                std::wstring wname(pe32.szExeFile);
                std::string name(wname.begin(), wname.end());
                
                // 프로세스 정보 추가
                updated_process.push_back({
                    static_cast<int>(pe32.th32ProcessID),
                    name
                });
            } while (Process32NextW(snapshot, &pe32));
        }
        CloseHandle(snapshot);
    }

    // 실제 데이터 업데이트
    {
        std::unique_lock<std::shared_mutex> lock(process_mutex);
        g_process = std::move(updated_process);
    }
    
    is_updating = false;
}

// 프로세스 목록을 출력하는 함수
void print_process(int id) {
    std::shared_lock<std::shared_mutex> lock(process_mutex);
    if (!g_process_cache || g_process_cache->size() != g_process.size()) {
        // 캐시가 없거나 크기가 다르면 캐시 업데이트
        g_process_cache = g_process;
    }
    lock.unlock();  // 캐시를 읽을 때는 잠금 해제

    // 캐시된 데이터 사용
    const auto& process_list = g_process_cache.value();
    std::cout << "Current Process List:  thread id=" << id << "\n";
    for (const auto& proc : process_list) {
        // std::cout << "PID: " << proc.pid << ", Name: " << proc.name << "\n";
    }
    std::cout << "Current Process Count : " << process_list.size() << "  thread id=" << id << "\n";
}

// 클라이언트 스레드
void client_thread(int id) {
    std::cout << "Client " << id << " started.\n";
    for (int i=0; i<10; i++  ) {
        update_process(id); // 프로세스 정보 갱신
        print_process(id);  // 최신 프로세스 정보 출력
        std::this_thread::sleep_for(std::chrono::milliseconds(rand()%100));   
    }
    std::cout << "Client " << id << " finished.\n";
}

int main() {

    update_process(0);

    // 여러 스레드에서 동작 시뮬레이션
    int thread_count = 10;
    std::vector<std::thread> threads;
    for(int i=0; i<thread_count; i++) {
        threads.push_back(std::thread(client_thread, i+1));
    }

    for(auto& thread : threads) {
        thread.join();
    }   

    return 0;
}

ViewPager가 ViewPager2 로 업데이트되면서 사용하는 방법이 바뀌었다.

상단에 탭 메뉴가 있어서 메뉴 클릭 또는 컨텐트를 좌우 슬라이드하며 다른 페이지로 변경한다.

- TabLayout을 쓰기 위해 Dependency에 별다르게 추가하지 않아도 기본으로 material이 들어가있다. 

'com.google.android.material:material:1.7.0'

- main activity layout에 tab layout 과 viewpager2 를 추가

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <com.google.android.material.tabs.TabLayout
        android:id="@+id/tablayout"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
    >

        <com.google.android.material.tabs.TabItem
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Monday" />

        <com.google.android.material.tabs.TabItem
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Tuesday" />

        <com.google.android.material.tabs.TabItem
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Wednesday" />
    </com.google.android.material.tabs.TabLayout>

    <androidx.viewpager2.widget.ViewPager2
        android:id="@+id/viewpager"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1"
        />

</LinearLayout>

- 각 탭별로 fragment xml 생성

frag_monday.xml, frag_tuesday.xml, frag_wednesday.xml 약간씩 바꿔서 확인.

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextView
        android:id="@+id/textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginStart="170dp"
        android:layout_marginTop="349dp"
        android:layout_marginEnd="170dp"
        android:text="Monday"
        android:textSize="20sp"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>

- 각 fragment 클래스 생성. 이것도 이름만 약간씩 다르게..

public class FragMonday extends Fragment {
    private View view ;
    public static FragMonday newInstance() {
        FragMonday fragMonday = new FragMonday();
        return fragMonday;
    }

    @Nullable
    @Override
    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        view = inflater.inflate(R.layout.frag_monday, container,  false) ;
        return view ;
    }

}

- Adapter를 만들어야 한다. ViewPagerAdapter class

public class ViewPagerAdapter extends FragmentStateAdapter {
    private final List<Fragment> fragmnets = new ArrayList<Fragment>() ;
    private final List<String> titles = new ArrayList<>() ;

    public ViewPagerAdapter(@NonNull FragmentActivity fragmentActivity) {
        super(fragmentActivity);
    }

    @NonNull
    @Override
    public Fragment createFragment(int position) {
        return fragmnets.get(position) ;
    }

    @Override
    public int getItemCount() {
        return fragmnets.size() ;
    }

    public void addFragment(@NonNull Fragment frag, String title) {
        fragmnets.add(frag) ;
        titles.add(title) ;
    }
    @NonNull
    public String getTitle(int position) {
        return titles.get(position) ;
    }

}

- 이제 MainActivity에서 모두 연결시킨다.

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        ViewPagerAdapter viewPagerAdapter = new ViewPagerAdapter(this);
        viewPagerAdapter.addFragment(FragMonday.newInstance(), "Monday");
        viewPagerAdapter.addFragment(FragTuesday.newInstance(), "Tuesday");
        viewPagerAdapter.addFragment(FragWednesday.newInstance(), "Wednesday");

        ViewPager2 viewPager = findViewById(R.id.viewpager);
        viewPager.setAdapter(viewPagerAdapter);

        TabLayout tabLayout = findViewById(R.id.tablayout);
        TabLayoutMediator tm = new TabLayoutMediator(tabLayout, viewPager, (tab, position) -> {
            tab.setText(viewPagerAdapter.getTitle(position)) ;
        }) ;
        tm.attach();
    }
}

끝.

Firebase DB를 사용하여 RecyclerView에 출력하고, 갱신 버튼을 눌러, DB를 reloading하여 출력해 보자.

1. dependency 추가

implementation 'androidx.recyclerview:recyclerview:1.3.0'
implementation 'com.github.bumptech.glide:glide:4.10.0'
annotationProcessor 'com.github.bumptech.glide:compiler:4.10.0'

2. activity_main.xml에 recyclerview 추가. reload 버튼 추가

<Button
    android:id="@+id/btn_Reload"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:text="reload"
    />

<androidx.recyclerview.widget.RecyclerView
    android:id="@+id/recyclerview"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    />

3. 아이템 디자인 list_item.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="wrap_content">
    <LinearLayout
        android:orientation="horizontal"
        android:layout_width="match_parent"
        android:layout_height="wrap_content">
        <ImageView
            android:id="@+id/iv_profile"
            android:layout_width="100dp"
            android:layout_height="100dp"
            android:src="@mipmap/ic_launcher"
            />
        <LinearLayout
            android:layout_marginLeft="15dp"
            android:gravity="center_vertical"
            android:layout_width="wrap_content"
            android:layout_height="match_parent"
            android:orientation="vertical"
            >
            <TextView
                android:id="@+id/tv_id"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="hello"/>
            <TextView
                android:id="@+id/tv_pw"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="hello"/>
            <TextView
                android:id="@+id/tv_userName"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="hello"/>
        </LinearLayout>
    </LinearLayout>
</LinearLayout>

4. 아이템 class. User class (getter and setter 는  alt+insert키로 쉽게 자동생성 하세요.. )

public class User {
    private String profile ;
    private String id ;
    private int pw ;
    private String userName ;

5. CustomAdapter class

public class CustomAdapter extends RecyclerView.Adapter<CustomAdapter.CustomViewHolder> {
    private ArrayList<User> arrayList ;
    private Context context ;

    public CustomAdapter(ArrayList<User> arrayList, Context context) {
        this.arrayList = arrayList;
        this.context = context;
    }

    @NonNull
    @Override
    public CustomAdapter.CustomViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
        View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.list_item, parent, false) ;
        CustomViewHolder holder = new CustomViewHolder(view) ;
        return holder; // 홀더 리턴
    }

    @Override
    public void onBindViewHolder(@NonNull CustomAdapter.CustomViewHolder holder, int position) {
        Glide.with(holder.itemView)
                .load(arrayList.get(position).getProfile())
                .into(holder.iv_profile) ;
        holder.tv_id.setText(arrayList.get(position).getId());
        holder.tv_pw.setText(String.valueOf(arrayList.get(position).getPw()));
        holder.tv_userName.setText(arrayList.get(position).getUserName());
    }

    @Override
    public int getItemCount() {
        return (arrayList!=null ? arrayList.size(): 0);
    }

    public class CustomViewHolder extends RecyclerView.ViewHolder {
        ImageView iv_profile ;
        TextView tv_id ;
        TextView tv_userName ;
        TextView tv_pw ;

        public CustomViewHolder(@NonNull View itemView) {
            super(itemView);
            iv_profile = itemView.findViewById(R.id.iv_profile) ;
            tv_id = itemView.findViewById(R.id.tv_id) ;
            tv_userName = itemView.findViewById(R.id.tv_userName) ;
            tv_pw = itemView.findViewById(R.id.tv_pw) ;

        }
    }
}

6. Firebase 설정.

Tools - firebase 선택.  (예전엔 수작업으로 한 거를 편리하게 다 해준다..)

우측에 Realtime Database 메뉴를 선택한다.  Get started with Realtime Database 로 가서, 차례로 진행한다.

connect your app to firebase ; 브라우저로 구글 로그인하여 firebase 콘솔로 가서 프로젝트 생성까지 진행됨.

(실시간 DB를 잘 만든다. 필드도  User class에 맞게 다 맞춘다. +를 눌러 User를 만들고 다시 +를 눌러 User_01을 만들고 다시 +를 눌러 profile, id, pw, userName 필드들을 만든다.   처음엔 사용법을 몰라 어렵다. 하위 노드를 위해 미리 +를 연속해서 눌러줘야 된다. 미리 만들고, 엔터치면 하위에 추가가 안되서 삽질.. )

Add the Realtime Database to your app ; dependency 등을 알아서 설정해 준다.

그러나,... 나의 경우는 빌드시 에러가...  찾아보니, 버전 문제가 또 있다... (어쩌라고.. 정말  막막하게 만드는  버전 호환성...)

build.gradle (project) 에서 4.3.10 으로 들어가 있는데 찾아보니 버전을 14로 올리면 해결된다고 해서 해보니 성공하였음.

classpath 'com.google.gms:google-services:4.3.14'

7.MainActivity에서 RecyclerView와 Adapter 연결 및 Firebase 연동...

public class MainActivity extends AppCompatActivity {
    private RecyclerView recyclerView ;
    private RecyclerView.Adapter adapter ;
    private RecyclerView.LayoutManager layoutManager ;
    private ArrayList<User> arrayList ;
    private FirebaseDatabase database ;
    private DatabaseReference databaseReference ;
    private ValueEventListener valueEventListener ;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        recyclerView = findViewById(R.id.recyclerview) ;
        recyclerView.setHasFixedSize(true);
        layoutManager = new LinearLayoutManager(this) ;
        recyclerView.setLayoutManager(layoutManager);
        arrayList = new ArrayList<User>() ;

        adapter = new CustomAdapter(arrayList, this) ;
        recyclerView.setAdapter(adapter);

        database = FirebaseDatabase.getInstance();
        databaseReference = database.getReference("User") ; // User table

        valueEventListener = new ValueEventListener() {
            @Override
            public void onDataChange(@NonNull DataSnapshot snapshot) {
                Log.e("AAA", "reload data") ;
                // 데이터를 수신.
                arrayList.clear();
                for (DataSnapshot ds : snapshot.getChildren()) {
                    User user = ds.getValue(User.class) ;
                    Log.e("AAA", user.getId()) ;
                    arrayList.add(user) ;
                }
                adapter.notifyDataSetChanged();
            }

            @Override
            public void onCancelled(@NonNull DatabaseError error) {
                Log.e("AAA", error.toString()) ;
            }
        } ;

        databaseReference.addListenerForSingleValueEvent(valueEventListener);

        findViewById(R.id.btn_Reload).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                databaseReference.addListenerForSingleValueEvent(valueEventListener);
            }
        });

    }
}

- Reload를 어떻게 하나 궁금했는데 찾아보니 위와 같이 하니 되었다. databaseReference에 리스너를 또 등록하면 됨. 그러면 노드들을 다시 가져오고 갱신되었다. 

안드로이드 스튜디오에서 okhttp3를 사용하여 JSON 데이터를 비동기 방식으로 전송하고 수신하는 코드는 다음과 같습니다. 

(참고 app: build.gradle의 dependencies에 추가)

implementation 'com.squareup.okhttp3:okhttp:4.9.3'

(manifest에 권한 추가)

<uses-permission android:name="android.permission.INTERNET"/>

import okhttp3.*;
import org.json.JSONException;
import org.json.JSONObject;
import java.io.IOException;

public class MainActivity extends AppCompatActivity {

    private OkHttpClient client = new OkHttpClient();
    private MediaType JSON = MediaType.parse("application/json; charset=utf-8");

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // JSON 객체 생성
        JSONObject json = new JSONObject();
        try {
            json.put("name", "John Doe");
            json.put("age", 30);
        } catch (JSONException e) {
            e.printStackTrace();
        }

        // RequestBody 생성
        RequestBody body = RequestBody.create(json.toString(), JSON);

        // Request 생성
        Request request = new Request.Builder()
                .url("https://example.com/api")
                .post(body)
                .build();

        // 비동기 방식으로 요청 전송
        client.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                e.printStackTrace();
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                if (!response.isSuccessful()) {
                    throw new IOException("Unexpected code " + response);
                }

                // 수신된 JSON 데이터 디버그 로그로 출력
                try {
                    String responseData = response.body().string();
                    JSONObject receivedJson = new JSONObject(responseData);
                    Log.d("Received JSON", receivedJson.toString());
                } catch (JSONException e) {
                    e.printStackTrace();
                }
            }
        });
    }
}

* 에러 관련

not permitted by network security policy

• 버전이 올라가면서 기본적으로 http는 거부한다.. 이런 에러를 만날 것이다.

android okhttp not permitted by network security policy

해결방안은... 
manifest, application 태그
android:usesCleartextTraffic="true"

• 하지만 스토어에 등록은 안될 것이다!!. https에 SSL 인증까지 해야 등록가능..
• 즉, 테스트 용도에서는 가능.

NetworkOnMainThreadException , StrictMode$AndroidBlockGuardPolicy

• 메인 쓰레드에서 네트웍을 블로킹방식 ( execute() )으로 하게 되면 만나는 에러...
• 쓰레드를 만들어 돌리든지, 비동기 방식으로 변경..

new Thread() {
    public void run() {
        try {
            listFile();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }
    }
}.start();

원격 mysql 서버에 있는 DB의 스키마 작성 쿼리만 얻고 싶을 때?

mysqldump --no-data -h [서버IP] -P [포트] -u [사용자] -p [DB명]

• 옵션 대문자 P와 소문자 p를 헛갈리지 않도록 주의!
• 보통 mysql 디폴트 포트는 3306 이지만 관리자가 변경할 수 도 있다. 
• --no-data 옵션으로 데이터는 받지 않고, 스키마만 받을 수 있다. (create table 만 나옴)
• -p 옵션은 password를 프롬프트로 입력받겠다는 의미이다. -p를 생략하면 패스워드 없이 인증하려고 시도하여 인증실패 날 수 있다. 프롬프트로 패스워드를 받지 않고 커맨드에 패스워드를 직접 넣으려면 -p[패스워드]  이렇게 공백없이 붙여쓴다.   -p 옵션뒤에 공백을 넣고 패스워드를 넣으면  프롬프트로 패스워드 넣으라고 나오고, 뒤에 나온 스트링을 DB명으로 인식하여 찾게 된다.

mysql 클라이언트 옵션도 동일하다..

• mysql  -h [서버IP] -P [포트] -u [사용자] -p
• mysql  -h [서버IP] -P [포트] -u [사용자] -p[패스워드]
• mysql  -h [서버IP] -P [포트] -u [사용자] -p [DB명]
• mysql  -h [서버IP] -P [포트] -u [사용자] -p[패스워드] [DB명]

( -h 옵션 생략시 로컬 호스트 , -P 생략시 3306, -p 생략시 암호없음)

tomcat 8 설치. 서비스 등록 스크립트

• OS 는 데비안
• openjdk 8 은 검색하면 쉽게 구할 수 있다.
• openjdk 8 로 tomcat 구동
• tomcat8 계정을 생성한다. (tomcat8 계정 권한으로 프로세스 구동)

- JDK 설치

cp openlogic-openjdk-8u342-b07-linux-x64.tar.gz /usr/lib/jvm/
cd /usr/lib/jvm
tar xvfz openlogic-openjdk-8u342-b07-linux-x64.tar.gz
mv openlogic-openjdk-8u342-b07-linux-x64 openjdk-8
rm openlogic-openjdk-8u342-b07-linux-x64.tar.gz

JAVA_HOME은 아래와 같다. 
/usr/lib/jvm/openjdk-8

- tomcat 설치

; tomcat 계정 생성
루트 계정으로 아래 작업!
useradd -d /home/tomcat8 -M tomcat8  ; 계정 생성. (홈디렉터리 생성하려면 -M 대신 -m)
(참고) userdel -r tomcat8  ; tomcat8 계정 및 폴더 삭제.

; apache-tomcat-8.5.84.tar.gz 을 설치할 위치로 복사. 
mv apache-tomcat-8.5.84.tar.gz /home
cd /home
tar xvfz apache-tomcat-8.5.84.tar.gz
mv apache-tomcat-8.5.84 tomcat8
; 이름을 간단하게 tomcat8로 변경. 위 tomcat8 계정의 home 디렉터리가 됨.

- 권한 설정
chown -R tomcat8:tomcat8 /home/tomcat8

- 기본적인 설정 작업
$ cd /home/tomcat8/conf
$ vi server.xml

; 예를 들어서 포트 변경을 다음과 같이 할 수 있다.  WAS 포트는 58080, 58443 으로 한다.
<Connector port="58080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="58443" />

AJP 포트는 58009 로 설정한다.
<Connector protocol="AJP/1.3"
               address="0.0.0.0"
               secretRequired="false"
               port="58009"
               redirectPort="58443" />

• 서비스 구동 스크립트
  (아래 내용을 그대로 붙여 넣으면 파일이 생성됨.)
  (직접 편집하려면 [Unit] 부터 EOF 이전까지 복사해서 붙여넣기 사용)
  경로명을 잘 확인한다.

cat << EOF > /etc/systemd/system/tomcat8.service
[Unit]
Description=Apache Tomcat Service
After=syslog.target network.target

[Service]
Type=forking

Environment="JAVA_HOME=/usr/lib/jvm/openjdk-8"
Environment="CATALINA_HOME=/home/tomcat8"
Environment="CATALINA_BASE=/home/tomcat8"
Environment="CATALINA_OPTS=-Xms512M -Xmx1024M -server -XX:+UseParallelGC"
Environment="JAVA_OPTS=-Djava.security.egd=file:///dev/urandom"

ExecStart=/home/tomcat8/bin/startup.sh
ExecStop=/home/tomcat8/bin/shutdown.sh

User=tomcat8
Group=tomcat8

[Install]
WantedBy=multi-user.target
EOF

• 서비스 자동 시작 등록 및 구동 테스트

systemctl enable tomcat8
systemctl start tomcat8
systemctl stop tomcat8

Openssl SSL 인증서 만들기 / 웹서버(apache2) SSL 설정

- pem, key 파일 생성

; 서버 개인키 발급
openssl genrsa -des3 -out server.key 2048

; 인증요청서 생성 (csr)
openssl req -new -key server.key -out server.csr
!!!! CN 입력(Common Name)시에 맵핑할 도메인을 적는다. www.abc.com !!!
; kr seoul seoul mycompany myteam www.abc.com 나머지는계속엔터.

; 개인키에서 패스워드 제거 (키에 패스워드가 있으면 아파치 구동시마다 물어보니
; 패스워드 지우면 편리, 기존 암호화 파일은 org로 백업.)
cp server.key server.key.org
openssl rsa -in server.key.org -out server.key

; 인증서 생성
openssl x509 -req -days 3650 -in server.csr -signkey server.key -out server.crt
; 이제 key와 crt 파일로 SSL 설정시 사용하면 된다. 또는 pem으로 변경하여 사용. 
; 형식변환
openssl x509 -outform pem -in server.crt -out servercert.pem

아래 두 파일을 사용하면 된다.
server.key
servercert.pem

- Apache2 웹서버에 SSL 설정

* 인증서 등록
$vi /etc/apache2/sites-available/default-ssl.conf
; 기존 SSLCertificateFile, SSLCertificateKeyFile 두 줄을 아래와 같이 수정한다. 
; (인증서 파일 경로 확인)

SSLCertificateFile /etc/apache2/servercert.pem
SSLCertificateKeyFile /etc/apache2/server.key
# AJP tomcat 연동을 할 경우에는 JkMount 설정으로 worker 연결한다. 
# JkMount /* myworker

* SSL 활성화
; 아래 커맨드들을 실행한다.

a2enmod ssl
cd /etc/apache2/sites-available
a2ensite default-ssl.conf

; apache2 재시작
systemctl restart apache2

docker debian apache2 tomcat 연동

도커 환경으로 apache 웹 서버와 뒤에 tomcat WAS를 1개 띄우는 형식. 두 개의 분리된 서버(Web, WAS)
웹 서버는 80포트로 받아서 WAS1에 8010 포트로 연결한다.

데비안으로 할 거라서 먼저 준비 과정이 필요함. 이미지를 만들기 위해 모든 설치과정 커맨드들을 준비해야 한다. 설정 파일들에서 어디를 고칠지 확인.

여기서는 foreground 로 실행할 예정.

test. 준비 과정.

docker run -it -p 80:80 -p 18080:8080 -p 443:443 -p 18443:8443 debian

docker run -it -p 80:80 -p 443:443 -p 18443:8443 myweb

$

apt update
apt install -y curl wget net-tools systemd vim
curl -sSL https://packages.sury.org/apache2/README.txt | bash -x
apt install apache2 libapache2-mod-jk openjdk-11-jre -y

mkdir -p /usr/local
cd /usr/local
wget --no-check-certificate https://archive.apache.org/dist/tomcat/tomcat-8/v8.5.51/bin/apache-tomcat-8.5.51.tar.gz
tar xvfz apache-tomcat-8.5.51.tar.gz
mv apache-tomcat-8.5.51 tomcat8
rm apache-tomcat-8.5.51.tar.gz

-----------------------------

# 도커라 systemctl 커맨드가 안됨. service 커맨드는 작동하네.
service apache2 start
service apache2 status

# 이렇게 실행하면 종료되지 않는다. 
환경변수 세팅 필요.
source /etc/apache2/envars

apachectl -D FOREGROUND
또는
/usr/sbin/apache2 -D FOREGROUND

바로 foreground로 돌리면 경로 없어서 실패가 발생함. 
mkdir -p /var/run/apache2

tomcat docker
http://IP:18080/

apache2
http://IP/

-- 설정 변경 스크립트를 만들기 위해... 
cat -n 000-default.conf ; 줄번호가 출력됨. 오호.. 이런 기능이!

설정파일에서 스트링 변경
worker 설정 경로를 따로 만들어 주었다. 
sed -i 's/libapache2-mod-jk\/workers.properties/apache2\/workers.properties/g' /etc/apache2/mods-available/jk.conf

13번 라인에 insert 하고 싶은데. 아래 baclash 사이에 내용을 쓴다. 
sed -i '줄번호i\내용\' 파일명  ; 줄번호라인 위에 한줄이 삽입됨. 
즉, 추가한 줄이 입력한 줄번호가 된다.

sed -i '13i\ JkMount /* myworker\' 000-default.conf



-- workers.properties
# cat workers.properties
#
workers.tomcat_home = /usr/local/tomcat8
workers.java_home = /usr/lib/jvm/java-11-openjdk-amd64

worker.list = myworker
worker.myworker.port = 8009
worker.myworker.host = mywas1c
worker.myworker.type = ajp13

web1 apache2 : myweb1 (HTTP)

root@mobiledeep:/home/psychic/docker/docker_gpms/web# cat Dockerfile
FROM debian

RUN apt update
RUN apt install -y curl wget net-tools systemd vim
RUN curl -sSL https://packages.sury.org/apache2/README.txt | bash -x
RUN apt install apache2 libapache2-mod-jk openjdk-11-jre -y

COPY workers.properties /etc/apache2/workers.properties
RUN sed -i 's/libapache2-mod-jk\/workers.properties/apache2\/workers.properties/g' /etc/apache2/mods-available/jk.conf
RUN sed -i '13i\ JkMount /* myworker\' /etc/apache2/sites-available/000-default.conf

#RUN mkdir -p /usr/local && cd /usr/local && wget --no-check-certificate https://archive.apache.org/dist/tomcat/tomcat-8/v8.5.51/bin/apache-tomcat-8.5.51.tar.gz && tar xvfz apache-tomcat-8.5.51.tar.gz && mv apache-tomcat-8.5.51 tomcat8
#RUN rm /usr/local/apache-tomcat-8.5.51.tar.gz

RUN mkdir -p /var/run/apache2
ENV APACHE_RUN_USER=www-data
ENV APACHE_RUN_GROUP=www-data
ENV APACHE_PID_FILE=/var/run/apache2/apache2.pid
ENV APACHE_RUN_DIR=/var/run/apache2
ENV APACHE_LOCK_DIR=/var/lock/apache2
ENV APACHE_LOG_DIR=/var/log/apache2
ENV export LANG=C

CMD ["/usr/sbin/apache2", "-D", "FOREGROUND"]
#CMD ["/bin/bash"]

EXPOSE 80
EXPOSE 443

구동 스크립트

root@mobiledeep:/home/psychic/docker/docker_gpms/web# cat startup.sh
# docker build -t myweb1 .
docker rm -f myweb1c
docker run --rm --name myweb1c -it -p 80:80 -p 443:443 --link mywas1c:mywas1c myweb1

• link 옵션 때문에 tomcat이 먼저 떠 있어서 작동한다.

tomcat 8.5 ; mywas1

root@mobiledeep:/home/psychic/docker/docker_gpms/was# cat Dockerfile
FROM debian

RUN apt update
RUN apt install -y curl wget net-tools systemd vim
RUN apt install openjdk-11-jre -y

RUN mkdir -p /usr/local && cd /usr/local && wget --no-check-certificate https://archive.apache.org/dist/tomcat/tomcat-8/v8.5.51/bin/apache-tomcat-8.5.51.tar.gz && tar xvfz apache-tomcat-8.5.51.tar.gz && mv apache-tomcat-8.5.51 tomcat8 && perl -p -i -e '$.==114 and print " <Connector protocol=\"AJP/1.3\" secretRequired=\"false\" address=\"0.0.0.0\" port=\"8009\" redirectPort=\"8443\" />\n"' /usr/local/tomcat8/conf/server.xml
ENTRYPOINT ["/usr/local/tomcat8/bin/catalina.sh", "run"]

#COPY server.xml /etc/apache2/qauth.conf
#CMD ["/usr/sbin/apache2", "-D", "FOREGROUND"]
#CMD ["/bin/bash"]

EXPOSE 8080
EXPOSE 8009
EXPOSE 8443

----
빌드
# docker build -t mywas1 .

• 구동 스크립트. foreground.

root@mobiledeep:/home/psychic/docker/docker_gpms/was# cat startup.sh
# docker build -t mywas1 .
docker rm -f mywas1c
docker run --rm --name mywas1c  -it -p 8080:8080 -p 8443:8443 -p 8009:8009 mywas1

web2 : SSL 설정 (myweb2)

• SSL 설정은 web 만 하면 된다.
• SSL 인증서는 테스트용으로 self-sign 인증서를 만들면 된다. (openssl 커맨드로 쉽게 만들 수 있음.)
• 필요한 커맨드 조사

기존에서 더 작업해야 할 것들.

sed -i '32,33d' /etc/apache2/sites-available/default-ssl.conf
sed -i '32i\SSLCertificateFile /etc/apache2/servercert.pem\' /etc/apache2/sites-available/default-ssl.conf
sed -i '33i\SSLCertificateKeyFile /etc/apache2/server.key\' /etc/apache2/sites-available/default-ssl.conf
sed -i '34i\JkMount /* myworker\' /etc/apache2/sites-available/default-ssl.conf

a2enmod ssl
cd /etc/apache2/sites-available
a2ensite default-ssl.conf

root@mobiledeep:/home/psychic/storage/docker/docker_gpms/web# cat Dockerfile
FROM debian

RUN apt update
RUN apt install -y curl wget net-tools systemd vim
RUN curl -sSL https://packages.sury.org/apache2/README.txt | bash -x
RUN apt install apache2 libapache2-mod-jk openjdk-11-jre -y

COPY workers.properties /etc/apache2/workers.properties

RUN sed -i 's/libapache2-mod-jk\/workers.properties/apache2\/workers.properties/g' /etc/apache2/mods-available/jk.conf
RUN sed -i '13i\ JkMount /* myworker\' /etc/apache2/sites-available/000-default.conf

# SSL
COPY server.key /etc/apache2/server.key
COPY servercert.pem /etc/apache2/servercert.pem
RUN sed -i '32,33d' /etc/apache2/sites-available/default-ssl.conf
RUN sed -i '32i\SSLCertificateFile /etc/apache2/servercert.pem\' /etc/apache2/sites-available/default-ssl.conf
RUN sed -i '33i\SSLCertificateKeyFile /etc/apache2/server.key\' /etc/apache2/sites-available/default-ssl.conf
RUN sed -i '34i\JkMount /* myworker\' /etc/apache2/sites-available/default-ssl.conf

#RUN mkdir -p /usr/local && cd /usr/local && wget --no-check-certificate https://archive.apache.org/dist/tomcat/tomcat-8/v8.5.51/bin/apache-tomcat-8.5.51.tar.gz && tar xvfz apache-tomcat-8.5.51.tar.gz && mv apache-tomcat-8.5.51 tomcat8
#RUN rm /usr/local/apache-tomcat-8.5.51.tar.gz

RUN mkdir -p /var/run/apache2
ENV APACHE_RUN_USER=www-data
ENV APACHE_RUN_GROUP=www-data
ENV APACHE_PID_FILE=/var/run/apache2/apache2.pid
ENV APACHE_RUN_DIR=/var/run/apache2
ENV APACHE_LOCK_DIR=/var/lock/apache2
ENV APACHE_LOG_DIR=/var/log/apache2
ENV export LANG=C

# SSL
RUN a2enmod ssl && cd /etc/apache2/sites-available && a2ensite default-ssl.conf

CMD ["/usr/sbin/apache2", "-D", "FOREGROUND"]
#CMD ["/bin/bash"]

EXPOSE 80
EXPOSE 443

구동스크립트

root@mobiledeep:/home/psychic/storage/docker/docker_gpms/web# cat startup.sh
docker build -t myweb1 .
docker rm -f myweb1c
docker run --rm --name myweb1c -it -p 80:80 -p 443:443 --link mywas1c:mywas1c myweb1