개발자를 위한 지침서

[CMake] 플러그인 빌드 구조 만들기 - 예제 2. 정적라이브러리 심볼 활용

i5 — Mon, 18 May 2026 00:19:20 +0900

실행파일 A가 플러그인 B를 동적로딩하고 이를 실행하는 예제를 살펴본다. 이 때, 각각 공통된 헤더(Log.h)를 사용하고 있고 이 Log.h의 구현부는 별도의 정적라이브러리(lib_src)로 실행파일 A 측에 구현되어있다.

1. 프로젝트 구조

.
├── CMakeLists.txt
├── main.cpp              # 실행 파일 (A)
├── plugin.cpp            # 플러그인 (B)
├── include_main/         # 메인용 헤더 디렉토리
│   └── Log.h
├── include_plugin/       # 플러그인용 헤더 디렉토리 (내용은 동일)
│   └── Log.h
└── lib_src/              # 정적 라이브러리 소스
    └── Log.cpp

2. 소스코드

Log.h (양쪽 폴더에 동일하게 복사)

#pragma once
class Log {
public:
    void print();
};

lib_src/Log.cpp (정적 라이브러리 구현부)

#include "Log.h" // 컴파일 시점의 경로를 따름
#include <iostream>

void Log::print() {
    std::cout << "[Main App's Static Lib] Hello from Log::print!" << std::endl;
}

main.cpp (실행 파일 A)

#include <iostream>
#include <dlfcn.h>
#include "Log.h" // include_main의 헤더 사용

int main() {
    Log mainLog;
    mainLog.print(); // 메인에서 사용 (whole-archive 없이 포함되도록 함)

    void* handle = dlopen("./libpluginB.so", RTLD_NOW);
    if (!handle) {
        std::cerr << "Load fail: " << dlerror() << std::endl;
        return 1;
    }

    auto run = (void (*)())dlsym(handle, "run_plugin");
    if (run) run();

    dlclose(handle);
    return 0;
}

plugin.cpp (공유 라이브러리 B)

#include "Log.h" // include_plugin의 헤더 사용 (경로가 다름)

extern "C" void run_plugin() {
    Log pluginLog;
    // 구현체가 없지만, 실행 시 메인 바이너리의 심볼을 찾아갑니다.
    pluginLog.print(); 
}

CMakeLists.txt

핵심은 --export-dynamic과 헤더 경로 설정이다.

cmake_minimum_required(VERSION 3.10)
project(CrossDirTest)

# 1. 정적 라이브러리 생성 (Main용 헤더 참조)
add_library(LogStatic STATIC lib_src/Log.cpp)
target_include_directories(LogStatic PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include_main)

# 2. 메인 실행 파일 생성
add_executable(AppA main.cpp)
target_link_libraries(AppA PRIVATE LogStatic ${CMAKE_DL_LIBS})

# [핵심] 메인 내부의 LogStatic 심볼을 플러그인이 볼 수 있게 공개
target_link_options(AppA PRIVATE "-Wl,--export-dynamic")

# 3. 플러그인 생성 (Plugin 전용 별도 헤더 경로 참조)
add_library(pluginB SHARED plugin.cpp)
# 구현체(Log.cpp)를 링크하지 않고 헤더만 참조함
target_include_directories(pluginB PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include_plugin)
set_target_properties(pluginB PROPERTIES PREFIX "lib" OUTPUT_NAME "pluginB")

3. 분석

위 코드를 빌드하고 실행하면 다음과 같은 흐름이 발생한다.

빌드 단계
- AppA는 LogStatic을 링크하여 Log::print의 기계어 코드를 자기 몸체에 포함한다.
- pluginB는 Log::print가 어디 있는지 모르지만, "나중에 누군가 채워주겠지" 하고 구멍(Undefined Symbol)을 남겨둔 채 빌드된다.
실행 단계 (./AppA)
- main()이 호출되어 첫 번째 "Hello..."를 출력한다.
- dlopen("./libpluginB.so")가 호출된다.
- 시스템의 동적 링커(ld.so)가 pluginB를 로드하면서 빈 구멍(Log::print)을 채우려 한다.
- AppA가 --export-dynamic으로 빌드되었으므로, 링커는 AppA 내부에서 Log::print 심볼을 찾아 pluginB와 연결해 준다.

4. 실행 결과

[Main App's Static Lib] Hello from Log::print!
[Main App's Static Lib] Hello from Log::print!

결과적으로, 이처럼 동일한 헤더 파일의 물리적 위치가 다르더라도, 클래스 이름과 함수 시그니처가 같으면 링커는 이를 동일한 대상으로 간주하고 성공적으로 연결한다. (--export-dynamic을 활용해야한다.)

단, 앞서 설명한 대로 한쪽 헤더에만 멤버 변수를 추가하는 등의 실수를 하면 Segmentation Fault가 발생할 수 있으니 내용 일치에만 주의하시면 된다.

5. 그림

위의 내용들을 간단하게 그림으로 나타내면 아래와 같다.

- 빌드타임

- 런타임

[CMake] 플러그인 빌드 구조 만들기 (--export-dynamic 활용)

i5 — Thu, 14 May 2026 02:11:51 +0900

CMake 환경에서 플러그인 빌드 구조를 만들기 위한 방법을 소개한다.

예시로 설명한 플러그인 구조 및 요구사항은 아래와 같다.

- main.cpp -> plugin.cpp의 .so파일을 load한다.

- plugin.cpp -> 공유라이브러리로 구현되어 산출물은 .so 파일이다.

- 플러그인이 main.cpp 측에 구현된 C++ 클래스를 사용이 가능하도록 구성한다.

1. 프로젝트 구조

.
├── CMakeLists.txt
├── Log.h          # main.cpp와 plugin.cpp가 공유하는 인터페이스
├── main.cpp       # 실행 파일 (구현체 포함)
└── plugin.cpp     # 공유 라이브러리

2. 소스코드

Log.h

#pragma once
#include <iostream>

class Log {
public:
    // 구현은 main.cpp에만 둘 예정
    void print();
};

main.cpp

실행 파일 (main)이 Log::print의 실체를 가지고 있으며, 플러그인 (plugin.cpp)을 로드한다.

#include <iostream>
#include <dlfcn.h>
#include "Log.h"

// Log 클래스의 구현부 - 실행 파일 A에 위치함
void Log::print() {
    std::cout << "Hello World from A's Log class!" << std::endl;
}

int main() {
    // 플러그인 B(libpluginB.so)를 로드
    void* handle = dlopen("./libpluginB.so", RTLD_NOW);
    if (!handle) {
        std::cerr << "Cannot open library: " << dlerror() << std::endl;
        return 1;
    }

    // 플러그인 내부의 'run_plugin' 함수 호출
    typedef void (*run_func)();
    run_func run = (run_func)dlsym(handle, "run_plugin");
    
    if (run) {
        run();
    } else {
        std::cerr << "Cannot load symbol 'run_plugin': " << dlerror() << std::endl;
    }

    dlclose(handle);
    return 0;
}

plugin.cpp (공유 라이브러리)

이 plugin은 Log.h만 알고 있고, 구현체가 없지만 Log 객체를 사용한다.

#include "Log.h"

extern "C" void run_plugin() {
    Log logger;
    // 플러그인에는 print()의 구현이 없지만, 실행 시 main쪽의 심볼을 찾아서 호출한다.
    logger.print();
}

CMakeLists.txt

여기서 --export-dynamic 설정이 핵심이다.

cmake_minimum_required(VERSION 3.10)
project(ExportDynamicTest)

# 1. 실행 파일 A 생성
add_executable(AppA main.cpp)

# --export-dynamic 옵션 부여 (A의 심볼을 외부에 노출)
target_link_options(AppA PRIVATE "-Wl,--export-dynamic")
# dlopen 기능을 위해 dl 라이브러리 링크 (리눅스)
target_link_libraries(AppA PRIVATE ${CMAKE_DL_LIBS})

# 2. 공유 라이브러리 B 생성
# 주의: 여기서는 Log.cpp(구현부)를 절대 추가하지 않습니다.
add_library(pluginB SHARED plugin.cpp)

# B는 링크 시점에 Log::print 심볼이 없어도 무시하도록 설정 (Undefined symbols)
# 하지만 보통 Linux 링커는 공유 라이브러리 빌드 시 
# 정의되지 않은 심볼이 있어도 기본적으로 허용합니다.

3. 테스트 및 결과

빌드

rm -rf build
mkdir build && cd build
cmake ..
make

실행

./AppA

결과

Hello World from A's Log class!

4. 고찰

만약 AppA의 target_link_options에서 -Wl,--export-dynamic을 제거하고 다시 빌드하면 어떻게 될까?

AppA는 문제없이 실행되지만, dlopen으로 pluginB를 로드하는 순간 다음과 같은 에러가 발생하며 중단된다.
undefined symbol: _ZN3Log5printEv (Log::print()의 망글링된 이름)

이는 pluginB가 자신의 메모리 안에서 Log::print를 찾지 못했고, 메인 프로그램(AppA)이 그 심볼을 공개하지 않았기 때문에 발생하는 현상이다. 따라서 --export-dynamic은 "내 안에 구현된 클래스 기능을 너(플러그인)에게 공유해줄게"라는 선언과 같다.

[CMake] target_include_directories와 target_link_libraries 개념

i5 — Mon, 11 May 2026 01:55:07 +0900

target_include_directories vs target_link_libraries 키워드

두 명령어 모두 PUBLIC / PRIVATE / INTERFACE 키워드를 사용하지만, 전파되는 속성(property)이 다르기 때문에 의미와 효과가 다릅니다.

핵심 개념: 두 가지 관점

관점	속성
헤더(컴파일)	INCLUDE_DIRECTORIES, INTERFACE_INCLUDE_DIRECTORIES
링크	LINK_LIBRARIES, INTERFACE_LINK_LIBRARIES

키워드는 "이 타겟 자신에게 적용되는가" 와 "이 타겟에 의존하는 타겟에게도 전파되는가" 를 동시에 제어합니다.

키워드 의미 (공통)

               나 자신에게 적용?   의존자에게 전파?
PRIVATE         ✅                  ❌
INTERFACE       ❌                  ✅
PUBLIC          ✅                  ✅

target_include_directories

컴파일 시 헤더 탐색 경로(-I)를 제어합니다.

target_include_directories(<target>
    PUBLIC    <include_dir>   # 나도 쓰고, 나를 쓰는 놈도 써야 함
    PRIVATE   <include_dir>   # 나만 씀 (구현 내부 헤더)
    INTERFACE <include_dir>   # 나는 안 씀, 나를 쓰는 놈만 써야 함
)

실제 예시

project/
├── libfoo/
│   ├── include/foo/foo.h      ← public API 헤더
│   ├── src/foo.cpp
│   └── src/internal/detail.h  ← 내부 구현 헤더
└── app/
    └── main.cpp               ← #include <foo/foo.h> 사용

# libfoo/CMakeLists.txt
add_library(foo STATIC src/foo.cpp)

target_include_directories(foo
    PUBLIC  ${CMAKE_CURRENT_SOURCE_DIR}/include     # foo.h → app도 필요
    PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src/internal # detail.h → foo만 필요
)

# app/CMakeLists.txt
add_executable(app main.cpp)
target_link_libraries(app PRIVATE foo)
# → app은 자동으로 include/foo 경로를 얻음 (foo의 PUBLIC이 전파됨)
# → src/internal 경로는 전파 안 됨

전파되는 CMake 내부 속성

키워드	자신의 속성	전파되는 속성
PRIVATE	INCLUDE_DIRECTORIES	—
INTERFACE	—	INTERFACE_INCLUDE_DIRECTORIES
PUBLIC	INCLUDE_DIRECTORIES	INTERFACE_INCLUDE_DIRECTORIES

target_link_libraries

링크 시 의존 라이브러리(-l, -L)를 제어합니다. 단, 키워드가 없으면 헤더 경로까지 함께 전파됩니다 (transitive dependency).

target_link_libraries(<target>
    PUBLIC    <lib>   # 나도 링크, 나를 쓰는 놈도 링크해야 함
    PRIVATE   <lib>   # 나만 링크 (구현 내부에서만 사용)
    INTERFACE <lib>   # 나는 링크 안 함, 나를 쓰는 놈이 링크해야 함
)

실제 예시: 3계층 의존성

app → libbar → libfoo

# libfoo
add_library(foo STATIC foo.cpp)
target_include_directories(foo PUBLIC include)

# libbar: foo를 PUBLIC으로 링크 → bar의 헤더에서 foo 타입을 노출함
add_library(bar STATIC bar.cpp)
target_link_libraries(bar PUBLIC foo)
#   bar.h 안에 foo::SomeType 사용 → app도 foo 헤더가 필요

# app
add_executable(app main.cpp)
target_link_libraries(app PRIVATE bar)
# → app은 bar도 링크, foo도 자동으로 링크됨 (bar의 PUBLIC 전파)
# → app은 foo의 include 경로도 자동으로 얻음

# 반대 케이스: foo가 bar 내부 구현에서만 쓰임
target_link_libraries(bar PRIVATE foo)
# → app은 foo를 링크 안 해도 됨
# → app은 foo 헤더 경로도 받지 않음

전파되는 CMake 내부 속성

키워드	자신의 속성	전파되는 속성
PRIVATE	LINK_LIBRARIES	—
INTERFACE	—	INTERFACE_LINK_LIBRARIES
PUBLIC	LINK_LIBRARIES	INTERFACE_LINK_LIBRARIES

두 명령어의 관계

target_link_libraries로 CMake 타겟을 연결하면, 링크뿐 아니라 그 타겟의 INTERFACE_INCLUDE_DIRECTORIES도 자동으로 전파됩니다.

target_link_libraries(app PRIVATE foo)
# 이 한 줄이 아래 두 줄을 암묵적으로 수행:
#   - app이 foo를 링크 (-lfoo)
#   - foo의 INTERFACE_INCLUDE_DIRECTORIES → app의 INCLUDE_DIRECTORIES로 추가

그래서 올바르게 구성된 라이브러리라면 target_link_libraries 하나만으로 충분하고, 별도의 target_include_directories를 소비자 쪽에서 쓸 필요가 없습니다.

판단 기준 요약

이 헤더/라이브러리가...
├── 내 .cpp 구현 파일에서만 쓰임?           → PRIVATE
├── 내 공개 헤더(.h)에 노출됨?              → PUBLIC
└── 내 헤더에만 노출, 내 .cpp엔 없음?       → INTERFACE
    (header-only 라이브러리가 대표적)

[CMake] CMake 명령어 순서에 대한 고찰

i5 — Mon, 11 May 2026 01:12:31 +0900

CMake는 imperative(명령형) 언어로 스크립트를 위에서 아래로 순차 실행하게 된다. 따라서, target이 존재하기 전에 그 target을 참조하면 오류가 나게 되는데, CMake 명령어 순서에 대해 정리해본다.

순서 규칙

1. add_library / add_executable → 반드시 target_* 보다 먼저 선언한다.

target을 생성해야 그 target에 속성을 붙일 수 있으므로 add_* 는 반드시 target_* 명령어보다 먼저 선언한다.

# 잘못된 예: 타겟이 아직 없음
target_link_libraries(mylib PRIVATE somelib)
add_library(mylib src.cpp)

# 올바른 예
add_library(mylib src.cpp)
target_link_libraries(mylib PRIVATE somelib)

2. target_* 명령어들 간의 순서 → 대체로 무관하다.

target_link_libraries, target_include_directories, target_compile_options 등은 타겟 생성 이후라면 상호 간 순서는 결과에 영향 없다.

add_library(mylib src.cpp)

# 아래 셋의 순서는 바꿔도 동일한 결과
target_include_directories(mylib PUBLIC include/)
target_compile_options(mylib PRIVATE -Wall)
target_link_libraries(mylib PRIVATE pthread)

3. find_package / pkg_check_modules → 사용 전에 먼저

이 명령어들은 import target이나 변수를 생성하므로, target_link_libraries에서 참조하기 전에 호출해야 합니다. import target에 대한 개념은 아래의 부록에서 설명한다.

find_package(sdbus-c++ REQUIRED)   # 먼저

add_executable(myapp main.cpp)
target_link_libraries(myapp PRIVATE SDBusCpp::sdbus-c++)  # 이후

4. 서브디렉토리 간 의존성 → add_subdirectory 순서가 중요

add_subdirectory(libfoo)   # foo 타겟 생성
add_subdirectory(app)      # app이 foo에 의존 → foo가 먼저여야 함

단, target_link_libraries로 연결된 타겟은 같은 CMake 빌드 트리 내라면 순서가 바뀌어도 CMake가 해결해 주는 경우도 있다. 하지만 명시적 순서를 유지하는 것이 안전하다.

권장 관용적 순서

# 1. 의존성 탐색
find_package(...)
pkg_check_modules(...)

# 2. 타겟 생성
add_library(mylib ...)
add_executable(myapp ...)

# 3. 타겟 속성 설정 (순서 무관)
target_include_directories(...)
target_compile_definitions(...)
target_compile_options(...)
target_link_libraries(...)

이 순서가 CMake 공식 튜토리얼과 대부분의 오픈소스 프로젝트에서 따르는 관례이다.

부록

1. 임포트 타겟 (Imported Target) 과 변수 (Variable)

■ 임포트 타겟 (Imported target)

find_package가 성공하면, CMake가 가상의 타겟을 생성하게 된다. 이 때, 실제 .a 혹은 .so 파일이 아니라, CMake 내부에만 존재하는 타겟이다.

find_package(sdbus-c++ REQUIRED)
# → SDBusCpp::sdbus-c++ 라는 임포트 타겟이 생성됨

target_link_libraries(myapp PRIVATE SDBusCpp::sdbus-c++)
#                                   ^^^^^^^^^^^^^^^^^^
#                                   이 타겟을 참조

이 임포트 타겟 안에는 아래 정보가 모두 내장되어 있다:

링크할 .so 경로
필요한 include 경로
필요한 컴파일 옵션
추이적 의존성 (transitive dependencies)

그래서 target_link_libraries 한 줄만 써도 include/link가 전부 해결된다.

■ 변수 (Variable)

pkg_check_modules 또는 구버전 find_package는 임포트 타겟 대신 변수를 설정한다:

pkg_check_modules(DBUS REQUIRED dbus-1)
# → 아래 변수들이 생성됨:
#   DBUS_INCLUDE_DIRS  = /usr/include/dbus-1.0 ...
#   DBUS_LIBRARIES     = dbus-1
#   DBUS_CFLAGS        = ...
#   DBUS_FOUND         = TRUE

target_include_directories(myapp PRIVATE ${DBUS_INCLUDE_DIRS})
target_link_libraries(myapp PRIVATE ${DBUS_LIBRARIES})
#                                   ^^^^^^^^^^^^^^^^
#                                   변수를 직접 참조

변수는 단순 문자열이므로, 직접 꺼내서 써야 한다.

■ 비교 요약

	임포트 타겟	변수
생성 방식	find_package (modern)	pkg_check_modules, 구버전 find_package
사용 방법	Foo::Bar 형태로 직접 전달	${FOO_LIBRARIES} 등 변수로 분리 전달
include/link	타겟 안에 통합	변수를 각각 따로 지정
추이적 의존성	자동 전파	수동 관리 필요
권장 여부	Modern CMake 권장	레거시 방식

■ 순서 측면

# ❌ find_package 전에 참조
target_link_libraries(myapp PRIVATE SDBusCpp::sdbus-c++)
find_package(sdbus-c++ REQUIRED)
# → SDBusCpp::sdbus-c++ 타겟이 아직 존재하지 않으므로 오류

# ✅ find_package 후에 참조
find_package(sdbus-c++ REQUIRED)
# → SDBusCpp::sdbus-c++ 타겟 생성 완료

target_link_libraries(myapp PRIVATE SDBusCpp::sdbus-c++)
# → 정상 참조 가능

add_library로 직접 만드는 타겟과 동일한 이유이다. 즉, 존재하기 전에 참조할 수 없다.

추가 궁금증

Q. install()은 명령어 순서는 중요하지 않습니까?

A. 타겟 생성(add_library/add_executable) 이후라면 어디서든 괜찮다.

install()은 빌드 시점이 아니라 cmake --install 단계에서만 실행되는 명령어이기 때문에, 빌드 의존성과 무관하다.

(작성중) yocto 변수

i5 — Sun, 10 May 2026 23:12:51 +0900

https://docs.yoctoproject.org/ref-manual/variables.html

이 홈페이지에서 원하는 변수명을 쉽게검색하려면 아래처럼 term- 뒤에 원하는 변수명을 검색해보자

https://docs.yoctoproject.org/ref-manual/variables.html#term-<원하는 변수명>

자주 쓰이는 변수

${D}
Destination directory. Build Directory 안에 있는 위치인데 그 위치에 component 들이 do_install task에 의해 설치된다.
( -> ${WORKDIR}/image )

${S}
Build Directory 안에 위치인데, 그 위치 안에 unpacked recipe source code 들이 있다. 기본 값으로 이 directory는 ${UNPACKDIR}/${BPN}-${PV]이다.

${PN}
레시피 이름 혹은 산출된 패키지 이름

[DBUS] gdbus-codegen 명령어로 API Docs(Documentation) 생성하기

i5 — Thu, 30 Apr 2026 19:09:10 +0900

gdbus-codegen 명령어로 documentation (XML 파일)을 생성하고 이를 HTML 파일로 나타내보자.

STEP 1. 패키지 설치하기

(1) libglib2.0-dev 패키지

먼저 gdbus-codegen 명령어를 실행하기 위해 libglib2.0-dev 패키지를 설치한다.

# 설치
sudo apt-get update
sudo apt-get install libglib2.0-dev

# 또는
sudo apt-get install libglib2.0-dev-bin

이후 아래 명령어로 설치확인을 해보자

# gdbus-codegen 존재 확인
which gdbus-codegen
# 예상 출력: /usr/bin/gdbus-codegen

# 버전 확인
# gdbus-codegen은 GLib의 일부이므로 버전이 동일
pkg-config --modversion glib-2.0
# 예상 출력: 2.72.4

(2) gtk-doc-tools 패키지

xml을 html로 변환하기 위해 gtk-doc 명령어를 써야하는데, 그러기 위해 필요한 패키지를 설치한다.

sudo apt install gtk-doc-tools

STEP 2. gdbus-codegen 명령어로 xml 형태의 Docs 생성

먼저 예제 DBus Instropection XML 파일을 생성하자

- org.example.Calculator.xml

<!DOCTYPE node PUBLIC
"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
<node name="/" xmlns:doc="http://www.freedesktop.org/dbus/1.0/doc.dtd">
  <interface name="org.example.Calculator">
      <!--
        Add:
        @a: The first double-precision floating-point number.
        @b: The second double-precision floating-point number.
        @result: The calculated sum of the two inputs.
        @response: server staus
        The @response indicates the server status:
        <simplelist>
              <member>0: Success, the request is carried out</member>
              <member>1: Server cancelled the interaction</member>
              <member>2: Sever interaction was ended in some other way</member>
        </simplelist>
        In the case of an error (response 2) @results may contain wrong value

        Computes the sum of @a and @b.
      -->
  	<method name="Add">
      <arg name="a" type="d" direction="in">
      </arg>
      <arg name="b" type="d" direction="in">
      </arg>
      <arg name="result" type="d" direction="out">
      </arg>
      <arg name="response" type="d" direction="out">
      </arg>
    </method>
	<!--
        Subtract:
        @a: The minuend (value to be subtracted from).
        @b: The subtrahend (value to subtract).
        @result: The arithmetic difference.

        Subtracts @b from @a and returns the difference.
  	-->
    <method name="Subtract">
      <arg name="a" type="d" direction="in" />
      <arg name="b" type="d" direction="in" />
      <arg name="result" type="d" direction="out" />
    </method>
    
	<!--
        CalculationFinished:
        @operation: A string representing the method name (e.g., "Add").

        Emitted when a calculation is successfully completed.

        Example @version:
        <variablelist>
          <varlistentry>
            <term>version s</term>
             <listitem><para>
             Version is version.
            </para></listitem>
          </varlistentry>
          <varlistentry>
            <term>isStable b</term>
            <listitem><para>
            chekc if It's stable or not
            </para></listitem>
          </varlistentry>
	</variablelist>
	Example description (@operation is good):

	Example description (@operation is good):

	Example description (@operation is good):
	-->
    <signal name="CalculationFinished">
      <arg name="operation" type="s">
      </arg>
    </signal>
  </interface>
</node>

이후 해당 org.example.Calculator.xml파일이 위치한 곳에서,

gdbus-codegen 명령어를 실행한다.

gdbus-codegen --generate-docbook=docs \
org.example.Calculator.xml

이렇게하면 docs-org.example.Calculator.xml 파일이 생성될 것이다.

STEP 3. Docs XML파일을 HTML로 변환하기

docs-org.example.Calculator.xml 파일이 있는 위치에서 아래의 명령어를 실행한다

mkdir -p html
cd html
gtkdoc-mkhtml docs ../docs-org.example.Calculator.xml

STEP 4. index.html 파일 실행하기

생성된 index.html파일을 실행하면 아래와 같이 API Docs가 생성된 걸 확인할 수 있다.

Reference

https://github.com/flatpak/flatpak/blob/c27af8a9d90af5573b74f832a079a498caf5d1d1/data/org.freedesktop.Flatpak.Authenticator.xml#L26

[C++] Singleton weak_ptr 사용

i5 — Wed, 29 Apr 2026 12:46:12 +0900

#include <iostream>
#include <memory>
#include <mutex>

// ============================================================
//  Singleton: shared_ptr + weak_ptr 기반 수명 관리
//  - 외부 shared_ptr이 모두 소멸 → ref count=0 → 자동 소멸
//  - weak_ptr은 count에 영향 없음 (소유권 없는 관찰자)
// ============================================================
class Singleton {
public:
    Singleton(const Singleton&)            = delete;
    Singleton& operator=(const Singleton&) = delete;
    Singleton(Singleton&&)                 = delete;
    Singleton& operator=(Singleton&&)      = delete;

    // private 소멸자에 접근 가능한 custom deleter
    struct Deleter {
        void operator()(Singleton* p) const { delete p; }
    };

    static std::shared_ptr<Singleton> getInstance() {
        std::lock_guard<std::mutex> lock(mutex_);

        auto sp = instance_.lock();   // weak_ptr → shared_ptr 승격 시도
        if (!sp) {
            sp = std::shared_ptr<Singleton>(new Singleton(), Deleter{});
            instance_ = sp;           // weak_ptr 갱신 (count 영향 없음)
        }
        return sp;
    }

    void doSomething() const {
        std::cout << "  doSomething() called. value=" << value_ << "\n";
    }

    void setValue(int v) { value_ = v; }
    int  getValue() const { return value_; }

private:
    Singleton() : value_(0) {
        std::cout << "[+] Singleton constructed\n";
    }
    ~Singleton() {
        std::cout << "[-] Singleton destroyed\n";
    }

    static std::weak_ptr<Singleton> instance_;
    static std::mutex               mutex_;

    int value_;
};

std::weak_ptr<Singleton> Singleton::instance_;
std::mutex               Singleton::mutex_;


// ============================================================
//  전달 방식별 ref count 변화 확인용 함수들
// ============================================================

// 1) 값 전달 → 복사 → count+1
void byValue(std::shared_ptr<Singleton> sp) {
    std::cout << "  [byValue]    use_count=" << sp.use_count() << "\n";
}

// 2) const 참조 전달 → count 변화 없음
void byConstRef(const std::shared_ptr<Singleton>& sp) {
    std::cout << "  [byConstRef] use_count=" << sp.use_count() << "\n";
}

// 3) move 전달 → 소유권 이전, count 변화 없음, 원본 nullptr
void byMove(std::shared_ptr<Singleton> sp) {
    std::cout << "  [byMove]     use_count=" << sp.use_count()
              << "  (소유권 이전됨)\n";
}


int main() {
    std::cout << "=== 1. 기본 생성 및 소멸 ===\n";
    {
        auto s1 = Singleton::getInstance();          // count=1
        std::cout << "  s1 use_count=" << s1.use_count() << "\n";
        {
            auto s2 = Singleton::getInstance();      // count=2
            std::cout << "  s2 use_count=" << s2.use_count() << "\n";
        }   // s2 소멸 → count=1
        std::cout << "  s2 소멸 후 s1 use_count=" << s1.use_count() << "\n";
    }   // s1 소멸 → count=0 → ~Singleton() 호출

    std::cout << "\n=== 2. 소멸 후 재생성 ===\n";
    {
        auto s3 = Singleton::getInstance();          // 새로 생성
        s3->setValue(99);
        s3->doSomething();
    }   // 소멸

    std::cout << "\n=== 3. 값 전달 (count+1) ===\n";
    {
        auto s1 = Singleton::getInstance();          // count=1
        std::cout << "  호출 전 use_count=" << s1.use_count() << "\n";
        byValue(s1);                                 // 함수 내 count=2
        std::cout << "  호출 후 use_count=" << s1.use_count() << "\n"; // count=1
    }

    std::cout << "\n=== 4. const 참조 전달 (count 유지) ===\n";
    {
        auto s1 = Singleton::getInstance();
        std::cout << "  호출 전 use_count=" << s1.use_count() << "\n";
        byConstRef(s1);
        std::cout << "  호출 후 use_count=" << s1.use_count() << "\n";
    }

    std::cout << "\n=== 5. move 전달 (소유권 이전) ===\n";
    {
        auto s1 = Singleton::getInstance();
        std::cout << "  move 전 use_count=" << s1.use_count() << "\n";
        byMove(std::move(s1));                       // s1 → nullptr
        std::cout << "  move 후 s1 is nullptr? "
                  << (s1 == nullptr ? "YES" : "NO") << "\n";
    }   // byMove 내부 sp 소멸 → count=0 → ~Singleton()

    std::cout << "\n=== 6. 동일 인스턴스 확인 ===\n";
    {
        auto s1 = Singleton::getInstance();
        auto s2 = Singleton::getInstance();
        std::cout << "  same instance? "
                  << (s1.get() == s2.get() ? "YES" : "NO") << "\n";
        std::cout << "  use_count=" << s1.use_count() << "\n";
    }

    std::cout << "\n[main 종료]\n";
    return 0;
}

# C++17 이상 필요
g++ -std=c++17 -Wall -Wextra -o singleton main.cpp
./singleton

[sdbus] sdbus 예제 05 - timer 예제 (sd_event 방법)

i5 — Fri, 24 Apr 2026 17:14:24 +0900

개요

sdbus에서 내부적으로 timer를 구현하려면 어떻게해야할까? 측, 특정 시간 이후 특정 콜백을 수행하게 하려면 어떻게 해야할까?

첫번째는 std::thread + sleep를 활용한 방법이 있고,

두번쨰는 sd_event 타이머 활용(systemd 환경)하는 방법이 있다.

첫번째 방법(std::thread + sleep)은 C++에서 전통적인 방법이다. 하지만 이 방법은 dbus 이벤트 루프와 통합되지 않고 별도로 콜백이 수행이 되기 때문에, 임계구역에 대해 신경을 써주어야한다.

두번째 방법(sd_event 타이머 활용)은 sd_event를 활용하여 타이머를 구현하는 방법이다. 이 방법으로 하면, 타이머 이후 수행되는 콜백은 이벤트 루프 스레드에서 살행된다. sdbus-c++가 내부적으로 sd_event를 사용하므로 이 방법을 쓸 수 있다.

두 방법을 비교하면 아래와 같다.

항목	std::thread	sd_event 타이머
의존성	없음	libsystemd 필요
정밀도	낮음	높음
이벤트 루프 통합	별도 스레드	이벤트 루프와 통합
thread-safe	주의 필요	이벤트 루프 스레드에서 실행
코드 복잡도	낮음	높음

systemd 환경이라면 sd_event 타이머가 이벤트 루프와 통합되어 더 안전하고, 간단히 구현하려면 std::thread 방식이 편리하다.

이 글에서는 sd_event 활용한 방법을 소개하겠다.

소스코드

프로젝트 구조

project/
├── CMakeLists.txt
├── dbus/
│   └── calculator.xml
├── generated/
│   ├── calculator-adaptor.h
│   └── calculator-proxy.h
├── server.cpp
└── client.cpp

server.cpp

#include <sdbus-c++/sdbus-c++.h>
#include <systemd/sd-event.h>
#include <iostream>
#include <csignal>
#include <cstring>
#include "generated/calculator-adaptor.h"

// 시간관련
#include <sstream>
#include <iomanip>
#include <chrono>

// 시간 헬퍼 + 로그 매크로
static std::string currentTime()
{
    auto now    = std::chrono::system_clock::now();
    auto time_t = std::chrono::system_clock::to_time_t(now);
    auto ms     = std::chrono::duration_cast<std::chrono::milliseconds>(
                      now.time_since_epoch()) % 1000;

    std::ostringstream oss;
    oss << std::put_time(std::localtime(&time_t), "%Y-%m-%d %H:%M:%S")
        << "." << std::setfill('0') << std::setw(3) << ms.count();

    return oss.str();
}

#define LOG(tag, msg) \
    std::cout << "[" << currentTime() << "] " \
              << "[" << (tag) << "] " << msg << "\n"

// 전역
static sd_event* g_event = nullptr;

static void onSignal(int)
{
    if (g_event)
        sd_event_exit(g_event, 0);
}

// CalculatorImpl
class CalculatorImpl
    : public sdbus::AdaptorInterfaces<org::example::Calculator_adaptor>
{
public:
    CalculatorImpl(sdbus::IConnection& conn, sdbus::ObjectPath path)
        : AdaptorInterfaces(conn, std::move(path))
    {
        registerAdaptor();
    }

    ~CalculatorImpl()
    {
        stopTimer();
        unregisterAdaptor();
    }

protected:
    int32_t Add(const int32_t& a, const int32_t& b) override
    {
        int32_t result = a + b;
        LOG("Add", a << " + " << b << " = " << result);

        // 이미 타이머 실행 중이면 재설정 안함
        if (timerSource_) {
            LOG("Timer", "이미 실행 중 → 재설정 안함");
        } else {
            startTimer();
        }

        return result;
    }

    int32_t Sub(const int32_t& a, const int32_t& b) override
    {
        int32_t result = a - b;
        LOG("Sub", a << " - " << b << " = " << result);

        // 타이머 해제
        stopTimer();

        return result;
    }

private:
    void startTimer()
    {
        sd_event* event = getObject().getConnection().getSdEventLoop();
        if (!event) {
            LOG("Timer", "getSdEventLoop() = nullptr");
            return;
        }

        uint64_t now{};
        sd_event_now(event, CLOCK_MONOTONIC, &now);

        int r = sd_event_add_time(
            event,
            &timerSource_,
            CLOCK_MONOTONIC,
            now + 5 * 1'000'000,  // 5초 후
            0,
            onTimer,
            this
        );

        if (r < 0) {
            LOG("Timer", "등록 실패: " << strerror(-r));
            return;
        }

        LOG("Timer", "시작 (5초 후 onTimerFired 호출)");
    }

    void stopTimer()
    {
        if (!timerSource_) return;

        sd_event_source_unref(timerSource_);
        timerSource_ = nullptr;
        LOG("Timer", "해제");
    }

    void onTimerFired()
    {
        LOG("Timer", "Hello World!");
        stopTimer();
    }

    static int onTimer(sd_event_source* source,
                       uint64_t         usec,
                       void*            userdata)
    {
        auto* self = static_cast<CalculatorImpl*>(userdata);
        self->onTimerFired();
        return 0;
    }

    sd_event_source* timerSource_{nullptr};
};

// main
int main()
{
    std::signal(SIGINT,  onSignal);
    std::signal(SIGTERM, onSignal);

    // 1. sd_event 생성
    int r = sd_event_default(&g_event);
    if (r < 0) {
        LOG("Server", "sd_event_default 실패: " << strerror(-r));
        return 1;
    }

    // 2. D-Bus connection 생성
    auto conn = sdbus::createSessionBusConnection(
        sdbus::ServiceName{"org.example.Calculator"}
    );

    // 3. sdbus를 sd_event에 attach
    conn->attachSdEventLoop(g_event);

    // 4. 서비스 등록
    CalculatorImpl calculator{
        *conn,
        sdbus::ObjectPath{"/org/example/Calculator"}
    };

    LOG("Server", "Running... (Ctrl+C to stop)");
    LOG("Server", "Add() → 타이머 시작 (실행 중이면 재설정 안함)");
    LOG("Server", "Sub() → 타이머 해제");

    // 5. sd_event 루프 실행
    r = sd_event_loop(g_event);
    if (r < 0) {
        LOG("Server", "sd_event_loop 실패: " << strerror(-r));
    }

    // 6. 정리
    conn->detachSdEventLoop();
    sd_event_unref(g_event);
    g_event = nullptr;

    LOG("Server", "Stopped");
    return 0;
}

client.cpp

#include <sdbus-c++/sdbus-c++.h>
#include <iostream>
#include <sstream>
#include <unistd.h>
#include "generated/calculator-proxy.h"

// 시간관련
#include <chrono>
#include <iomanip>

// 시간 헬퍼 + 로그 매크로
static std::string currentTime()
{
    auto now    = std::chrono::system_clock::now();
    auto time_t = std::chrono::system_clock::to_time_t(now);
    auto ms     = std::chrono::duration_cast<std::chrono::milliseconds>(
                      now.time_since_epoch()) % 1000;

    std::ostringstream oss;
    oss << std::put_time(std::localtime(&time_t), "%Y-%m-%d %H:%M:%S")
        << "." << std::setfill('0') << std::setw(3) << ms.count();

    return oss.str();
}

#define LOG(tag, msg) \
    std::cout << "[" << currentTime() << "] " \
              << "[" << (tag) << "] " << msg << "\n"

// CalculatorClient
class CalculatorClient
    : public sdbus::ProxyInterfaces<org::example::Calculator_proxy>
{
public:
    CalculatorClient(sdbus::ServiceName dest, sdbus::ObjectPath path)
        : ProxyInterfaces(std::move(dest), std::move(path))
    {
        registerProxy();
    }

    ~CalculatorClient()
    {
        unregisterProxy();
    }
};

// main
int main()
{
    CalculatorClient client{
        sdbus::ServiceName{"org.example.Calculator"},
        sdbus::ObjectPath{"/org/example/Calculator"}
    };

    // 1. Add 호출 → 타이머 시작
    LOG("Client", "Add(10, 3) 호출");
    auto result1 = client.Add(10, 3);
    LOG("Client", "결과: " << result1);

    sleep(1);

    // 2. Add 재호출 → 이미 실행 중이므로 재설정 안함
    LOG("Client", "Add(5, 2) 재호출 (타이머 실행 중)");
    auto result2 = client.Add(5, 2);
    LOG("Client", "결과: " << result2);

    sleep(1);

    // 3. Sub 호출 → 타이머 해제
    LOG("Client", "Sub(10, 3) 호출 → 타이머 해제");
    auto result3 = client.Sub(10, 3);
    LOG("Client", "결과: " << result3);

    sleep(1);

    // 4. Add 재호출 → 새 타이머 시작
    LOG("Client", "Add(7, 1) 재호출 → 새 타이머 시작");
    auto result4 = client.Add(7, 1);
    LOG("Client", "결과: " << result4);

    // 5. 5초 대기 → Hello World 출력 확인
    LOG("Client", "5초 대기 중...");
    sleep(6);

    LOG("Client", "종료");
    return 0;
}

CMakeLists.txt

cmake_minimum_required(VERSION 3.14)
project(timer_dbus_example CXX)
set(CMAKE_CXX_STANDARD 20)

find_package(sdbus-c++ REQUIRED)
find_package(PkgConfig REQUIRED)
pkg_check_modules(SYSTEMD REQUIRED libsystemd)
find_program(SDBUS_XML2CPP sdbus-c++-xml2cpp REQUIRED)

add_custom_command(
    OUTPUT
        ${CMAKE_CURRENT_SOURCE_DIR}/generated/calculator-adaptor.h
        ${CMAKE_CURRENT_SOURCE_DIR}/generated/calculator-proxy.h
    COMMAND ${SDBUS_XML2CPP}
        ${CMAKE_CURRENT_SOURCE_DIR}/dbus/calculator.xml
        --adaptor=${CMAKE_CURRENT_SOURCE_DIR}/generated/calculator-adaptor.h
        --proxy=${CMAKE_CURRENT_SOURCE_DIR}/generated/calculator-proxy.h
    DEPENDS dbus/calculator.xml
    COMMENT "Generating D-Bus glue code"
)
add_custom_target(generate_dbus_glue DEPENDS
    ${CMAKE_CURRENT_SOURCE_DIR}/generated/calculator-adaptor.h
    ${CMAKE_CURRENT_SOURCE_DIR}/generated/calculator-proxy.h
)

add_executable(server server.cpp)
target_include_directories(server PRIVATE
    ${CMAKE_CURRENT_SOURCE_DIR}
    ${CMAKE_CURRENT_SOURCE_DIR}/generated
    ${SYSTEMD_INCLUDE_DIRS}
)
target_link_libraries(server
    SDBusCpp::sdbus-c++
    ${SYSTEMD_LIBRARIES}
)
add_dependencies(server generate_dbus_glue)

add_executable(client client.cpp)
target_include_directories(client PRIVATE
    ${CMAKE_CURRENT_SOURCE_DIR}
    ${CMAKE_CURRENT_SOURCE_DIR}/generated
)
target_link_libraries(client SDBusCpp::sdbus-c++)
add_dependencies(client generate_dbus_glue)

빌드 및 실행

- 빌드

# 빌드
rm -rf build generated
mkdir generated
mkdir build && cd build
cmake ..
make -j$(nproc)

- 실행

# 터미널 1: 서버
#./server

# 터미널 2: 클라이언트
#./client

출력화면

server 측

$ ./server 
[2026-04-26 23:46:49.489] [Server] Running... (Ctrl+C to stop)
[2026-04-26 23:46:49.489] [Server] Add() → 타이머 시작 (실행 중이면 재설정 안함)
[2026-04-26 23:46:49.489] [Server] Sub() → 타이머 해제

// 1회차
[2026-04-26 23:46:53.916] [Add] 10 + 3 = 13
[2026-04-26 23:46:53.916] [Timer] 시작 (5초 후 onTimerFired 호출)
[2026-04-26 23:46:54.918] [Add] 5 + 2 = 7
[2026-04-26 23:46:54.918] [Timer] 이미 실행 중 → 재설정 안함
[2026-04-26 23:46:55.919] [Sub] 10 - 3 = 7
[2026-04-26 23:46:55.919] [Timer] 해제
[2026-04-26 23:46:56.920] [Add] 7 + 1 = 8
[2026-04-26 23:46:56.920] [Timer] 시작 (5초 후 onTimerFired 호출)
[2026-04-26 23:47:02.059] [Timer] Hello World!
[2026-04-26 23:47:02.059] [Timer] 해제

// 2회차
[2026-04-26 23:54:40.578] [Add] 10 + 3 = 13
[2026-04-26 23:54:40.578] [Timer] 시작 (5초 후 onTimerFired 호출)
[2026-04-26 23:54:41.578] [Add] 5 + 2 = 7
[2026-04-26 23:54:41.578] [Timer] 이미 실행 중 → 재설정 안함
[2026-04-26 23:54:42.579] [Sub] 10 - 3 = 7
[2026-04-26 23:54:42.579] [Timer] 해제
[2026-04-26 23:54:43.580] [Add] 7 + 1 = 8
[2026-04-26 23:54:43.580] [Timer] 시작 (5초 후 onTimerFired 호출)
[2026-04-26 23:54:48.809] [Timer] Hello World!
[2026-04-26 23:54:48.809] [Timer] 해제

client 측

// 1회차
$ ./client 
[2026-04-26 23:46:53.916] [Client] Add(10, 3) 호출
[2026-04-26 23:46:53.917] [Client] 결과: 13
[2026-04-26 23:46:54.917] [Client] Add(5, 2) 재호출 (타이머 실행 중)
[2026-04-26 23:46:54.918] [Client] 결과: 7
[2026-04-26 23:46:55.918] [Client] Sub(10, 3) 호출 → 타이머 해제
[2026-04-26 23:46:55.919] [Client] 결과: 7
[2026-04-26 23:46:56.919] [Client] Add(7, 1) 재호출 → 새 타이머 시작
[2026-04-26 23:46:56.920] [Client] 결과: 8
[2026-04-26 23:46:56.921] [Client] 5초 대기 중...
[2026-04-26 23:47:02.921] [Client] 종료

// 2회차
$ ./client 
[2026-04-26 23:54:40.577] [Client] Add(10, 3) 호출
[2026-04-26 23:54:40.578] [Client] 결과: 13
[2026-04-26 23:54:41.578] [Client] Add(5, 2) 재호출 (타이머 실행 중)
[2026-04-26 23:54:41.579] [Client] 결과: 7
[2026-04-26 23:54:42.579] [Client] Sub(10, 3) 호출 → 타이머 해제
[2026-04-26 23:54:42.579] [Client] 결과: 7
[2026-04-26 23:54:43.580] [Client] Add(7, 1) 재호출 → 새 타이머 시작
[2026-04-26 23:54:43.581] [Client] 결과: 8
[2026-04-26 23:54:43.581] [Client] 5초 대기 중...
[2026-04-26 23:54:49.581] [Client] 종료

만약 client에서 Sub(타이머 해제하는 요청)을 보내지 않는다면, server측 출력은 아래와 같이 출력된다.

$ ./server 
[2026-04-27 00:23:24.552] [Server] Running... (Ctrl+C to stop)
[2026-04-27 00:23:24.552] [Server] Add() → 타이머 시작 (실행 중이면 재설정 안함)
[2026-04-27 00:23:24.553] [Server] Sub() → 타이머 해제

[2026-04-27 00:23:28.275] [Add] 10 + 3 = 13
[2026-04-27 00:23:28.275] [Timer] 시작 (5초 후 onTimerFired 호출)
[2026-04-27 00:23:29.276] [Add] 5 + 2 = 7
[2026-04-27 00:23:29.277] [Timer] 이미 실행 중 → 재설정 안함
[2026-04-27 00:23:30.278] [Add] 7 + 1 = 8
[2026-04-27 00:23:30.278] [Timer] 이미 실행 중 → 재설정 안함
[2026-04-27 00:23:33.309] [Timer] Hello World!
[2026-04-27 00:23:33.309] [Timer] 해제

[sdbus] sdbus 예제 04 - Signal 구독 예제 (+ sdbus-c++-xml2cpp 활용)

i5 — Fri, 24 Apr 2026 01:37:36 +0900

특정 Bus에서 전송(emit)하는 시그널을 구독하는 방법을 소개한다.

소스코드

프로젝트 구조

project/
├── CMakeLists.txt
├── dbus/
│   └── calculator.xml
├── generated/
│   ├── calculator-adaptor.h
│   └── calculator-proxy.h
├── server.cpp
└── client.cpp

CMakeLists.txt

cmake_minimum_required(VERSION 3.14)
project(signal_example CXX)
set(CMAKE_CXX_STANDARD 20)

find_package(sdbus-c++ REQUIRED)
find_program(SDBUS_XML2CPP sdbus-c++-xml2cpp REQUIRED)

add_custom_command(
    OUTPUT
        ${CMAKE_CURRENT_SOURCE_DIR}/generated/calculator-adaptor.h
        ${CMAKE_CURRENT_SOURCE_DIR}/generated/calculator-proxy.h
    COMMAND ${SDBUS_XML2CPP}
        ${CMAKE_CURRENT_SOURCE_DIR}/dbus/calculator.xml
        --adaptor=${CMAKE_CURRENT_SOURCE_DIR}/generated/calculator-adaptor.h
        --proxy=${CMAKE_CURRENT_SOURCE_DIR}/generated/calculator-proxy.h
    DEPENDS dbus/calculator.xml
    COMMENT "Generating D-Bus glue code"
)
add_custom_target(generate_dbus_glue DEPENDS
    ${CMAKE_CURRENT_SOURCE_DIR}/generated/calculator-adaptor.h
    ${CMAKE_CURRENT_SOURCE_DIR}/generated/calculator-proxy.h
)

add_executable(server server.cpp)
target_include_directories(server PRIVATE
    ${CMAKE_CURRENT_SOURCE_DIR}
    ${CMAKE_CURRENT_SOURCE_DIR}/generated
)
target_link_libraries(server SDBusCpp::sdbus-c++)
add_dependencies(server generate_dbus_glue)

add_executable(client client.cpp)
target_include_directories(client PRIVATE
    ${CMAKE_CURRENT_SOURCE_DIR}
    ${CMAKE_CURRENT_SOURCE_DIR}/generated
)
target_link_libraries(client SDBusCpp::sdbus-c++)
add_dependencies(client generate_dbus_glue)

dbus/calculator.xml

<?xml version="1.0" encoding="UTF-8"?>
<node>
  <interface name="org.example.Calculator">

    <method name="Add">
      <arg name="a" type="i" direction="in"/>
      <arg name="b" type="i" direction="in"/>
      <arg name="result" type="i" direction="out"/>
    </method>

    <method name="Sub">
      <arg name="a" type="i" direction="in"/>
      <arg name="b" type="i" direction="in"/>
      <arg name="result" type="i" direction="out"/>
    </method>

    <signal name="ResultCalculated">
      <arg name="operation" type="s"/>
      <arg name="result"    type="i"/>
    </signal>

  </interface>
</node>

server.cpp

#include <sdbus-c++/sdbus-c++.h>
#include <iostream>
#include <csignal>
#include "generated/calculator-adaptor.h"

static sdbus::IConnection* g_conn = nullptr;

static void onSignal(int)
{
    if (g_conn)
        g_conn->leaveEventLoop();
}

class CalculatorImpl
    : public sdbus::AdaptorInterfaces<org::example::Calculator_adaptor>
{
public:
    CalculatorImpl(sdbus::IConnection& conn, sdbus::ObjectPath path)
        : AdaptorInterfaces(conn, std::move(path))
    {
        registerAdaptor();
    }

    ~CalculatorImpl()
    {
        unregisterAdaptor();
    }

protected:
    int32_t Add(const int32_t& a, const int32_t& b) override
    {
        int32_t result = a + b;
        std::cout << "[Server] Add(" << a << ", " << b
                  << ") = " << result << "\n";

        // signal emit
        emitResultCalculated("Add", result);

        return result;
    }

    int32_t Sub(const int32_t& a, const int32_t& b) override
    {
        int32_t result = a - b;
        std::cout << "[Server] Sub(" << a << ", " << b
                  << ") = " << result << "\n";

        // signal emit
        emitResultCalculated("Sub", result);

        return result;
    }
};

int main()
{
    std::signal(SIGINT,  onSignal);
    std::signal(SIGTERM, onSignal);

    auto conn = sdbus::createSessionBusConnection(
        sdbus::ServiceName{"org.example.Calculator"}
    );
    g_conn = conn.get();

    CalculatorImpl calculator{
        *conn,
        sdbus::ObjectPath{"/org/example/Calculator"}
    };

    std::cout << "[Server] Running... (Ctrl+C to stop)\n";
    conn->enterEventLoop();
    std::cout << "[Server] Stopped\n";

    return 0;
}

client.cpp (proxy 상속 없이 uponSignal 사용)

#include <sdbus-c++/sdbus-c++.h>
#include <iostream>
#include <unistd.h>

int main()
{
    // ✅ proxy 직접 생성 (상속 없음)
    auto proxy = sdbus::createProxy(
        sdbus::ServiceName{"org.example.Calculator"},
        sdbus::ObjectPath{"/org/example/Calculator"}
    );

    sdbus::InterfaceName ifaceName{"org.example.Calculator"};

    // ✅ uponSignal로 signal 구독
    proxy->uponSignal(sdbus::SignalName{"ResultCalculated"})
         .onInterface(ifaceName)
         .call([](const std::string& operation, const int32_t& result) {
             std::cout << "[Signal] ResultCalculated:"
                       << " operation=" << operation
                       << " result="    << result << "\n";
         });

    // Add 호출
    std::cout << "[Client] Add(10, 3) 호출\n";
    int32_t addResult{};
    proxy->callMethod("Add")
         .onInterface(ifaceName)
         .withArguments(int32_t{10}, int32_t{3})
         .storeResultsTo(addResult);
    std::cout << "[Client] Add 결과: " << addResult << "\n";

    sleep(1);

    // Sub 호출
    std::cout << "[Client] Sub(10, 3) 호출\n";
    int32_t subResult{};
    proxy->callMethod("Sub")
         .onInterface(ifaceName)
         .withArguments(int32_t{10}, int32_t{3})
         .storeResultsTo(subResult);
    std::cout << "[Client] Sub 결과: " << subResult << "\n";

    sleep(1);

    return 0;
}

만약 bus servie 이름과 object 이름을 생략하고 싶다면 addMatch를 이용한다.

#include <sdbus-c++/sdbus-c++.h>
#include <iostream>
#include <unistd.h>

int main()
{
    auto conn = sdbus::createSessionBusConnection();

    // ✅ interface명과 signal명만으로 구독
    const std::string matchRule =
        "type='signal',"
        "interface='org.example.Calculator',"
        "member='ResultCalculated'";

    conn->addMatch(
        matchRule,
        [](sdbus::Message msg) {
            std::string operation{};
            int32_t     result{};
            msg >> operation >> result;
            std::cout << "[Signal] operation=" << operation
                      << " result=" << result << "\n";
        }
    );

    std::cout << "[Client] signal 대기중...\n";
    conn->enterEventLoop();

    return 0;
}

만약 proxy를 상속하여 사용하고 싶은 경우, 아래의 client.cpp 코드를 참고한다.

#include <sdbus-c++/sdbus-c++.h>
#include <iostream>
#include <unistd.h>
#include "generated/calculator-proxy.h"

class CalculatorClient
    : public sdbus::ProxyInterfaces<org::example::Calculator_proxy>
{
public:
    CalculatorClient(sdbus::ServiceName dest, sdbus::ObjectPath path)
        : ProxyInterfaces(std::move(dest), std::move(path))
    {
        registerProxy();
    }

    ~CalculatorClient()
    {
        unregisterProxy();
    }

protected:
    // signal 수신 콜백
    void onResultCalculated(const std::string& operation,
                            const int32_t&     result) override
    {
        std::cout << "[Signal] ResultCalculated:"
                  << " operation=" << operation
                  << " result="    << result << "\n";
    }
};

int main()
{
    CalculatorClient client{
        sdbus::ServiceName{"org.example.Calculator"},
        sdbus::ObjectPath{"/org/example/Calculator"}
    };

    // Add 호출 → 서버에서 ResultCalculated signal emit
    std::cout << "[Client] Add(10, 3) 호출\n";
    auto addResult = client.Add(10, 3);
    std::cout << "[Client] Add 결과: " << addResult << "\n";

    sleep(1);

    // Sub 호출 → 서버에서 ResultCalculated signal emit
    std::cout << "[Client] Sub(10, 3) 호출\n";
    auto subResult = client.Sub(10, 3);
    std::cout << "[Client] Sub 결과: " << subResult << "\n";

    sleep(1);

    return 0;
}

빌드 및 실행

- 빌드

rm -rf build
rm -rf generated
mkdir generated
mkdir build && cd build
cmake ..
make -j$(nproc)

- 실행

# 터미널 1: 서버
#./server

# 터미널 2: 클라이언트
#./client

출력결과

- server측 터미널

[Server] Running... (Ctrl+C to stop)
[Server] Add(10, 3) = 13
[Server] Sub(10, 3) = 7

[Server] Add(10, 3) = 13
[Server] Sub(10, 3) = 7
[Server] Stopped

- client측 터미널

$ ./client 
[Client] Add(10, 3) 호출
[Client] Add 결과: 13
[Signal] ResultCalculated: operation=Add result=13
[Client] Sub(10, 3) 호출
[Client] Sub 결과: 7
[Signal] ResultCalculated: operation=Sub result=7

$ ./client 
[Client] Add(10, 3) 호출
[Signal] ResultCalculated: operation=Add result=13
[Client] Add 결과: 13
[Client] Sub(10, 3) 호출
[Client] Sub 결과: 7
[Signal] ResultCalculated: operation=Sub result=7

(작성중( sdbus timer

i5 — Thu, 23 Apr 2026 15:55:55 +0900

cmake_minimum_required(VERSION 3.14)
project(timer_example CXX)
set(CMAKE_CXX_STANDARD 20)

find_package(sdbus-c++ REQUIRED)

find_package(PkgConfig REQUIRED)
pkg_check_modules(SYSTEMD REQUIRED libsystemd)

add_executable(server server.cpp)
target_include_directories(server PRIVATE ${SYSTEMD_INCLUDE_DIRS})
target_link_libraries(server
    SDBusCpp::sdbus-c++
    ${SYSTEMD_LIBRARIES}
)

#include <sdbus-c++/sdbus-c++.h>
#include <systemd/sd-event.h>
#include <iostream>
#include <csignal>

//------------------------------------------------------------
// 전역 sd_event (signal 핸들러에서 루프 종료용)
//------------------------------------------------------------
static sd_event* g_event = nullptr;

static void onSignal(int)
{
    if (g_event)
        sd_event_exit(g_event, 0);
}

//------------------------------------------------------------
// TimerService: connection을 주입받아 타이머 관리
//------------------------------------------------------------
class TimerService
{
public:
    explicit TimerService(sdbus::IConnection& conn)
        : mConn_(conn)
    {}

    ~TimerService()
    {
        stopTimer();
    }

    void startTimer()
    {
        // 기존 타이머 제거
        stopTimer();

        // ✅ getSdEventLoop()로 sd_event 핸들 가져오기
        sd_event* event = mConn_.getSdEventLoop();
        if (!event) {
            std::cerr << "[Timer] sd_event loop not available\n";
            return;
        }

        uint64_t now{};
        sd_event_now(event, CLOCK_MONOTONIC, &now);

        int r = sd_event_add_time(
            event,
            &timerSource_,
            CLOCK_MONOTONIC,
            now + 5 * 1'000'000,  // 5초 후 (microsecond)
            0,
            onTimer,
            this
        );

        if (r < 0) {
            std::cerr << "[Timer] 등록 실패: " << strerror(-r) << "\n";
            return;
        }

        std::cout << "[Timer] 시작 (5초 후 onTimerFired 호출)\n";
    }

    void stopTimer()
    {
        if (!timerSource_) return;

        sd_event_source_unref(timerSource_);
        timerSource_ = nullptr;
        std::cout << "[Timer] 해제\n";
    }

private:
    void onTimerFired()
    {
        std::cout << "[Timer] 5초 경과 → onTimerFired 실행!\n";

        // timerSource_ 정리 (단발성)
        stopTimer();

        // 원하는 작업 수행
        std::cout << "[Timer] 작업 완료\n";
    }

    static int onTimer(sd_event_source* source,
                       uint64_t         usec,
                       void*            userdata)
    {
        auto* self = static_cast<TimerService*>(userdata);
        self->onTimerFired();
        return 0;
    }

    sdbus::IConnection& mConn_;
    sd_event_source*    timerSource_{nullptr};
};

//------------------------------------------------------------
// main
//------------------------------------------------------------
int main()
{
    // 1. sd_event 생성
    sd_event* event{};
    int r = sd_event_default(&event);
    if (r < 0) {
        std::cerr << "sd_event_default failed: " << strerror(-r) << "\n";
        return 1;
    }
    g_event = event;

    // 2. SIGINT/SIGTERM 처리
    std::signal(SIGINT,  onSignal);
    std::signal(SIGTERM, onSignal);

    // 3. D-Bus connection 생성
    auto conn = sdbus::createSessionBusConnection(
        sdbus::ServiceName{"org.example.Calculator"}
    );

    // 4. ✅ sdbus connection을 sd_event에 attach
    conn->attachSdEventLoop(event);

    // 5. TimerService 생성 및 타이머 시작
    //    attachSdEventLoop() 이후에 getSdEventLoop()가 유효한 포인터 반환
    TimerService timerService{*conn};
    timerService.startTimer();

    std::cout << "[Server] Running... (Ctrl+C to stop)\n";

    // 6. ✅ sd_event 루프 실행 (sdbus + 타이머 통합)
    r = sd_event_loop(event);
    if (r < 0) {
        std::cerr << "sd_event_loop failed: " << strerror(-r) << "\n";
    }

    // 7. 정리
    conn->detachSdEventLoop();
    sd_event_unref(event);
    g_event = nullptr;

    std::cout << "[Server] Stopped\n";
    return 0;
}

# 빌드
mkdir build && cd build
cmake ..
make -j$(nproc)

# 실행
./server

#include <sdbus-c++/sdbus-c++.h>
#include <systemd/sd-event.h>
#include <iostream>

class TimerService
{
public:
    // ✅ 생성자에서 connection 주입
    explicit TimerService(sdbus::IConnection& conn)
        : mConnection_(conn)
    {}

    ~TimerService()
    {
        stopTimer();
    }

    void startTimer()
    {
        stopTimer();

        // ✅ 주입받은 connection으로 getEventLoopHandle() 호출
        sd_event* event = static_cast<sd_event*>(
            mConnection_.getEventLoopHandle()
        );

        uint64_t now{};
        sd_event_now(event, CLOCK_MONOTONIC, &now);

        int r = sd_event_add_time(
            event,
            &timerSource_,
            CLOCK_MONOTONIC,
            now + 5 * 1'000'000,
            0,
            onTimer,
            this
        );

        if (r < 0) {
            std::cerr << "[Timer] 등록 실패: " << strerror(-r) << "\n";
            return;
        }

        std::cout << "[Timer] 시작 (5초 후 실행)\n";
    }

    void stopTimer()
    {
        if (!timerSource_) return;

        sd_event_source_unref(timerSource_);
        timerSource_ = nullptr;
        std::cout << "[Timer] 해제\n";
    }

private:
    void onTimerFired()
    {
        std::cout << "[Timer] 5초 경과 → onTimerFired 실행!\n";

        stopTimer();

        // 원하는 작업 수행
    }

    static int onTimer(sd_event_source* source,
                       uint64_t         usec,
                       void*            userdata)
    {
        auto* self = static_cast<TimerService*>(userdata);
        self->onTimerFired();
        return 0;
    }

    sdbus::IConnection& mConnection_;       // ✅ 주입받은 connection
    sd_event_source*    timerSource_{nullptr};
};

int main()
{
    auto conn = sdbus::createSessionBusConnection(
        sdbus::ServiceName{"org.example.Calculator"}
    );

    // ✅ 같은 connection 주입
    TimerService timerService{*conn};
    timerService.startTimer();

    conn->enterEventLoop();
    return 0;
}

타이머해제방법
// ✅ 방법 1: SD_EVENT_OFF로 비활성화 (source는 유지)
sd_event_source_set_enabled(timerSource_, SD_EVENT_OFF);

// ✅ 방법 2: unref로 완전 제거
sd_event_source_unref(timerSource_);
timerSource_ = nullptr;

class CalculatorImpl
    : public sdbus::AdaptorInterfaces<org::example::Calculator_adaptor>
{
public:
    CalculatorImpl(sdbus::IConnection& conn, sdbus::ObjectPath path)
        : AdaptorInterfaces(conn, std::move(path))
    {
        registerAdaptor();
        setupTimer();
    }

    ~CalculatorImpl()
    {
        stopTimer();
        unregisterAdaptor();
    }

protected:
    int32_t Add(const int32_t& a, const int32_t& b) override
    {
        // Add 호출 시 타이머 시작
        startTimer();
        return a + b;
    }

    int32_t Sub(const int32_t& a, const int32_t& b) override
    {
        // Sub 호출 시 타이머 해제
        stopTimer();
        return a - b;
    }

private:
    void setupTimer()
    {
        sd_event* event = static_cast<sd_event*>(
            getObject().getConnection().getEventLoopHandle()
        );

        uint64_t now{};
        sd_event_now(event, CLOCK_MONOTONIC, &now);

        sd_event_add_time(
            event,
            &timerSource_,
            CLOCK_MONOTONIC,
            now + 5 * 1'000'000,
            0,
            onTimer,
            this
        );

        // ✅ 처음엔 비활성화 상태로 등록
        sd_event_source_set_enabled(timerSource_, SD_EVENT_OFF);
        std::cout << "[Timer] Registered (inactive)\n";
    }

    // ✅ 타이머 시작
    void startTimer()
    {
        if (!timerSource_) return;

        sd_event* event = static_cast<sd_event*>(
            getObject().getConnection().getEventLoopHandle()
        );

        // 현재 시간 기준으로 재설정
        uint64_t now{};
        sd_event_now(event, CLOCK_MONOTONIC, &now);

        sd_event_source_set_time(timerSource_, now + 5 * 1'000'000);
        sd_event_source_set_enabled(timerSource_, SD_EVENT_ONESHOT);
        std::cout << "[Timer] Started\n";
    }

    // ✅ 타이머 해제
    void stopTimer()
    {
        if (!timerSource_) return;

        // 방법 1: 비활성화만 (재사용 가능)
        sd_event_source_set_enabled(timerSource_, SD_EVENT_OFF);
        std::cout << "[Timer] Stopped\n";

        // 방법 2: 완전 제거 (재사용 불가)
        // sd_event_source_unref(timerSource_);
        // timerSource_ = nullptr;
    }

    static int onTimer(sd_event_source* source,
                       uint64_t         usec,
                       void*            userdata)
    {
        auto* self = static_cast<CalculatorImpl*>(userdata);

        std::cout << "[Timer] Fired!\n";

        // 반복 타이머
        sd_event_source_set_time(source, usec + 5 * 1'000'000);
        sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);

        return 0;
    }

    sd_event_source* timerSource_{nullptr};
};

SD_EVENT_OFF vs unref 비교
항목
SD_EVENT_OFF
unref
source 메모리
유지
해제
재시작 가능
✅ set_enabled(ONESHOT)
❌ 재등록 필요
적합한 상황
일시 중지 후 재사용
완전히 제거
일시적으로 멈췄다가 다시 쓸 거라면 SD_EVENT_OFF, 완전히 제거할 거라면 unref 를 사용하면 됩니다.

void setupTimer()
{
    sd_event* event = static_cast<sd_event*>(
        getObject().getConnection().getEventLoopHandle()
    );

    uint64_t now{};
    sd_event_now(event, CLOCK_MONOTONIC, &now);

    // ✅ 람다를 heap에 저장 후 userdata로 전달
    auto* callback = new std::function<void(sd_event_source*, uint64_t)>(
        [this](sd_event_source* source, uint64_t usec) {
            std::cout << "[Timer] Fired!\n";

            // 원하는 작업
            emitSubResult(42);

            // 반복 타이머
            sd_event_source_set_time(source, usec + 5 * 1'000'000);
            sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
        }
    );

    sd_event_add_time(
        event,
        &timerSource_,
        CLOCK_MONOTONIC,
        now + 5 * 1'000'000,
        0,
        // ✅ wrapper: userdata를 std::function으로 캐스팅해서 호출
        [](sd_event_source* source, uint64_t usec, void* userdata) -> int {
            auto* cb = static_cast<std::function<void(sd_event_source*, uint64_t)>*>(userdata);
            (*cb)(source, usec);
            return 0;
        },
        callback  // userdata
    );

    // ✅ source 소멸 시 람다 자동 정리
    sd_event_source_set_userdata(timerSource_, callback);
    sd_event_source_set_destroy_callback(timerSource_,
        [](void* userdata) {
            auto* cb = static_cast<std::function<void(sd_event_source*, uint64_t)>*>(userdata);
            delete cb;
        }
    );
}

더깔끔하게ㅜ핼퍼로

// TimerHelper.h
#pragma once
#include <systemd/sd-event.h>
#include <functional>
#include <stdexcept>

inline sd_event_source* addTimer(
    sd_event*  event,
    uint64_t   intervalUs,  // microsecond
    std::function<void(sd_event_source*, uint64_t)> callback)
{
    uint64_t now{};
    sd_event_now(event, CLOCK_MONOTONIC, &now);

    auto* cb = new std::function<void(sd_event_source*, uint64_t)>(
        std::move(callback)
    );

    sd_event_source* source{nullptr};
    int r = sd_event_add_time(
        event,
        &source,
        CLOCK_MONOTONIC,
        now + intervalUs,
        0,
        [](sd_event_source* s, uint64_t usec, void* userdata) -> int {
            auto* cb = static_cast<
                std::function<void(sd_event_source*, uint64_t)>*>(userdata);
            (*cb)(s, usec);
            return 0;
        },
        cb
    );

    if (r < 0) {
        delete cb;
        throw std::runtime_error("Failed to add timer");
    }

    sd_event_source_set_destroy_callback(source,
        [](void* userdata) {
            delete static_cast<
                std::function<void(sd_event_source*, uint64_t)>*>(userdata);
        }
    );

    return source;
}

헬퍼함수 사용예시

#include "TimerHelper.h"

void setupTimer()
{
    sd_event* event = static_cast<sd_event*>(
        getObject().getConnection().getEventLoopHandle()
    );

    // ✅ static 함수, this 전달 없이 깔끔하게 사용
    timerSource_ = addTimer(
        event,
        5 * 1'000'000,  // 5초
        [this](sd_event_source* source, uint64_t usec) {
            std::cout << "[Timer] Fired!\n";

            emitSubResult(42);

            // 반복
            sd_event_source_set_time(source, usec + 5 * 1'000'000);
            sd_event_source_set_enabled(source, SD_EVENT_ONESHOT);
        }
    );
}

문서	내용
add_library	타겟 생성
target_link_libraries	"The named <target> must have been created by a command such as add_executable() or add_library()" 명시
cmake-buildsystem(7)	타겟/의존성 전체 개념 설명
CMake Tutorial	실제 순서를 보여주는 예제

개발자를 위한 지침서

[CMake] 플러그인 빌드 구조 만들기 - 예제 2. 정적라이브러리 심볼 활용

1. 프로젝트 구조

2. 소스코드

3. 분석

4. 실행 결과

5. 그림

[CMake] 플러그인 빌드 구조 만들기 (--export-dynamic 활용)

1. 프로젝트 구조

2. 소스코드

3. 테스트 및 결과

4. 고찰

[CMake] target_include_directories와 target_link_libraries 개념

target_include_directories vs target_link_libraries 키워드

핵심 개념: 두 가지 관점

키워드 의미 (공통)

target_include_directories

전파되는 CMake 내부 속성

target_link_libraries

전파되는 CMake 내부 속성

두 명령어의 관계

판단 기준 요약

[CMake] CMake 명령어 순서에 대한 고찰

순서 규칙

1. add_library / add_executable → 반드시 target_* 보다 먼저 선언한다.

2. target_* 명령어들 간의 순서 → 대체로 무관하다.

3. find_package / pkg_check_modules → 사용 전에 먼저

4. 서브디렉토리 간 의존성 → add_subdirectory 순서가 중요

관련 공식 문서

권장 관용적 순서

부록

1. 임포트 타겟 (Imported Target) 과 변수 (Variable)

추가 궁금증

(작성중) yocto 변수

[DBUS] gdbus-codegen 명령어로 API Docs(Documentation) 생성하기

STEP 1. 패키지 설치하기

STEP 2. gdbus-codegen 명령어로 xml 형태의 Docs 생성

STEP 3. Docs XML파일을 HTML로 변환하기

STEP 4. index.html 파일 실행하기

Reference

[C++] Singleton weak_ptr 사용

[sdbus] sdbus 예제 05 - timer 예제 (sd_event 방법)

개요

소스코드

프로젝트 구조

server.cpp

client.cpp

CMakeLists.txt

빌드 및 실행

출력화면

[sdbus] sdbus 예제 04 - Signal 구독 예제 (+ sdbus-c++-xml2cpp 활용)

소스코드

프로젝트 구조

CMakeLists.txt

dbus/calculator.xml

server.cpp

client.cpp (proxy 상속 없이 uponSignal 사용)

빌드 및 실행

출력결과

(작성중( sdbus timer