파일 그대로 복사해서 쓰는 실제 코드

-- "기본기능 (Lua)" 항목: 시스템 상태 — tapas.system_render()가 core의
-- view_system.c(view=system과 완전히 같은 코드)를 그대로 호출해서
-- config-only 쪽과 100% 동일한 화면을 낸다. 재구현이 아니라 진짜 같은
-- C 함수를 부르는 것.
local M = {}

function M.update()
    tapas.system_update()
end

function M.render(p)
    tapas.system_render(p)
end

return M

-- [1단계] 필드 하나 추가하기 — "기본기능 (Lua)"의 프로세스 목록은 core를
-- 그대로 보여주기만 했다(재구현 없음). 여기서는 그 결과에 Lua로 계산한
-- 컬럼 하나만 얹는다 — config.lua 선언(view=/file=)만으로는 존재하지 않는
-- 필드를 만들어낼 수 없지만, Lua 코드 몇 줄이면 된다는 걸 보여주는 가장
-- 쉬운 예시.
local M = {}

function M.update() end

local scroll = 0
local last_page_size = 20
local last_total = 0

function M.render(p)
	local t = tapas.view_table("process")
	if not t then
		tapas.render_kv(p, { { name = "오류", value = "process 뷰를 찾을 수 없습니다" } })
		return
	end

	-- 원본 헤더(PID/프로세스/CPU%/MEM%/상태) 뒤에 파생 컬럼 하나만 추가한다.
	local headers = {}
	for i, h in ipairs(t.headers) do headers[i] = h end
	table.insert(headers, "CPU+MEM")

	local rows = {}
	for i, row in ipairs(t.rows) do
		local new_row = {}
		for j, cell in ipairs(row) do new_row[j] = cell end
		-- tapas.view_table()의 각 셀은 항상 { value=.., color=.. } 테이블로
		-- 온다 — CPU%(3번째 컬럼)와 MEM%(4번째 컬럼) 값을 더해서 새 컬럼으로 붙인다.
		local cpu = tonumber(row[3].value) or 0
		local mem = tonumber(row[4].value) or 0
		table.insert(new_row, string.format("%.1f", cpu + mem))
		rows[i] = new_row
	end

	-- list_cols>1이면 화면당 실제로 보이는 건 한 단(per_col)뿐이라 —
	-- widget_render_table_cols()가 내부에서 하듯 스크롤 범위도 전체 행이
	-- 아니라 per_col(= 전체를 list_cols로 나눈 몫, 올림) 기준으로 잡아야
	-- PgDn이 빈 화면 없이 끝까지 정확히 맞아떨어진다.
	local list_cols = tapas.list_cols()
	local per_col = math.ceil(#rows / list_cols)

	last_page_size = p.rows - 1
	last_total = per_col
	tapas.render_table(p, 0, headers, rows, scroll, list_cols)
end

function M.handle_key(key)
	local handled
	scroll, handled = tapas.scroll_key(key, scroll, last_total, last_page_size)
	return handled
end

return M

-- [2단계] 조건에 따라 색 칠하기 — core가 이미 정해둔 색(위험/경고) 대신
-- 이 화면만의 기준으로 직접 색을 다시 정한다. config.lua 선언만으로는
-- "이 값이 이 조건이면 이 색"이라는 판단 자체를 넣을 수 없지만, Lua는
-- if/else 몇 줄이면 된다.
local M = {}

function M.update() end

local scroll = 0
local last_page_size = 20
local last_total = 0

-- 데모용 임계값 — 실제 운영 기준에 맞게 바꿔 쓰면 된다.
local WARN_CPU = 1.0
local DANGER_CPU = 5.0

function M.render(p)
	local t = tapas.view_table("process")
	if not t then
		tapas.render_kv(p, { { name = "오류", value = "process 뷰를 찾을 수 없습니다" } })
		return
	end

	local rows = {}
	for i, row in ipairs(t.rows) do
		local new_row = {}
		for j, cell in ipairs(row) do new_row[j] = cell end

		-- CPU%(3번째 컬럼)만 이 화면만의 임계값으로 다시 색칠한다.
		local cpu = tonumber(row[3].value) or 0
		local color = "normal"
		if cpu >= DANGER_CPU then
			color = "danger"
		elseif cpu >= WARN_CPU then
			color = "warn"
		end
		new_row[3] = { value = row[3].value, color = color }

		rows[i] = new_row
	end

	local list_cols = tapas.list_cols()
	local per_col = math.ceil(#rows / list_cols)

	last_page_size = p.rows - 1
	last_total = per_col
	tapas.render_table(p, 0, t.headers, rows, scroll, list_cols)
end

function M.handle_key(key)
	local handled
	scroll, handled = tapas.scroll_key(key, scroll, last_total, last_page_size)
	return handled
end

return M

-- [3단계] 여러 소스 합치기 — config.lua의 view=/file= 항목 하나는 소스
-- 하나만 가리킨다. 화면 하나에서 시스템 상태 + 메시지 큐 + 디스크를 동시에
-- 요약하려면 이 화면처럼 Lua에서 여러 tapas.* 호출 결과를 한 곳에 모아야
-- 한다 — declarative한 config.lua 선언만으로는 불가능한 조합.
local M = {}

function M.update() end

function M.render(p)
	local sys = tapas.system_read()
	local queue = tapas.view_table("queue")
	local disk = tapas.view_table("disk")

	local rows = {
		{ name = "CPU 사용률", value = string.format("%d%%", sys.cpu_pct) },
		{ name = "메모리 사용률", value = string.format("%d%% (%d/%dMB)", sys.mem_pct, sys.mem_used_mb, sys.mem_total_mb) },
		{ name = "로드 애버리지", value = string.format("%.2f / %.2f / %.2f", sys.load1, sys.load5, sys.load15) },
		{ name = "메시지 큐 개수", value = tostring(queue and #queue.rows or 0) },
		{ name = "디스크 마운트 수", value = tostring(disk and #disk.rows or 0) },
	}

	tapas.render_kv(p, rows, 0, tapas.list_cols())
end

function M.handle_key(key) return false end

return M

-- [4단계] 이력을 들고 있다가 그래프로 그리기 — config.lua는 "지금 이
-- 순간의 값"만 다룬다. 시간에 따른 추이를 보여주려면 매 갱신마다 값을
-- 어딘가에 쌓아 둬야 하는데, 그 "상태"를 들고 있을 곳이 필요하다.
-- file= 모듈은 core(src/view_runner.c lua_load_module)가 레지스트리에
-- 캐시해서 재사용하므로, 모듈 최상위 local 변수가 매 update()/render()
-- 호출 사이에 값을 유지한다 — 이게 이력을 쌓을 수 있는 이유다.
local M = {}

local MAX_POINTS = 60
local history_cpu = {}
local history_mem = {}

function M.update()
	local sys = tapas.system_read()
	table.insert(history_cpu, sys.cpu_pct)
	table.insert(history_mem, sys.mem_pct)
	if #history_cpu > MAX_POINTS then table.remove(history_cpu, 1) end
	if #history_mem > MAX_POINTS then table.remove(history_mem, 1) end
end

function M.render(p)
	local charts = {
		{ name = "CPU %", values = history_cpu, max = 100, warn_at = 0.6, danger_at = 0.85 },
		{ name = "MEM %", values = history_mem, max = 100, warn_at = 0.6, danger_at = 0.85 },
	}
	tapas.render_linegraph(p, 0, charts, 8, "area")
end

function M.handle_key(key) return false end

return M

-- [5단계] 평균 대비 급등 감지 알람 — 1~3단계는 "지금 이 값"을 가져다
-- 가공만 했고, 4단계는 그 값을 시간순으로 쌓아 그래프로 그리기만 했다.
-- 여기서는 그 이력을 근거로 "판단"을 직접 짠다 — 이동평균을 계산하고,
-- 지금 값이 평균보다 얼마나 튀었는지 보고, 몇 번 연속으로 튀었는지 세서
-- (한 틱만 튄 건 노이즈로 보고 무시) 진짜 경보인지 스스로 결정한다.
-- tapas.*는 원시값(system_read)만 준다 — 평균/편차/연속횟수/경보 여부라는
-- "로직"은 전부 이 파일이 프로그램으로 짠 것이다.
local M = {}

local MAX_POINTS = 30
local SPIKE_RATIO = 1.5    -- 이동평균보다 이 배수 이상이면 "튐" 후보
local MIN_BASELINE = 5     -- 평균이 너무 낮으면(0에 가까우면) 배수 비교가 과민해지므로 무시
local ALERT_AFTER = 3      -- 연속 이만큼 튀어야 진짜 경보로 취급(순간 튐은 무시)

local history = {}
local streak = 0

function M.update()
	local sys = tapas.system_read()
	table.insert(history, sys.cpu_pct)
	if #history > MAX_POINTS then table.remove(history, 1) end
end

function M.render(p)
	local cur = history[#history] or 0
	local sum = 0
	for _, v in ipairs(history) do sum = sum + v end
	local avg = #history > 0 and (sum / #history) or 0

	local spiking = avg >= MIN_BASELINE and cur >= avg * SPIKE_RATIO
	streak = spiking and (streak + 1) or 0

	local status, color
	if streak >= ALERT_AFTER then
		status, color = "ALERT", "danger"
	elseif spiking then
		status, color = "감시중", "warn"
	else
		status, color = "정상", "good"
	end

	local dev_pct = avg > 0 and ((cur - avg) / avg * 100) or 0

	tapas.render_table(p, 0,
		{ "현재 CPU%", "이동평균(30틱)", "평균 대비", "연속 초과", "상태" },
		{ {
			string.format("%.1f", cur),
			string.format("%.1f", avg),
			string.format("%+.0f%%", dev_pct),
			tostring(streak),
			{ value = status, color = color },
		} })
end

function M.handle_key(key) return false end

return M

-- 여러 SHM에 흩어진 항목을 msg_code 기준으로 합쳐서 하나의 표로 보여준다.
-- 실무에서 흔한 경우: 수신/처리/DB적재가 서로 다른 프로세스라 SHM도 각자
-- 따로 관리한다 — SHM 구조체 뷰 엔진(view_shmstruct.c)은 SHM 하나만
-- 다루도록 설계돼 있어서(전문별 처리 건수 예시 참고), 이런 조인은
-- config.lua(view=)만으로는 안 되고 Lua 파일(file=)이 필요하다.
local M = {}

local RECV_SPEC = {
	shm_key = 0x1301,
	header  = "examples/msg_recv_stats.h",
	struct  = "RECV_STATS.data",
	header_struct = "RECV_STATS_HEADER",
	count_field = "cur_cnt",
}
local PROC_SPEC = {
	shm_key = 0x1302,
	header  = "examples/msg_proc_stats.h",
	struct  = "PROC_STATS.data",
	header_struct = "PROC_STATS_HEADER",
	count_field = "cur_cnt",
}
local DB_SPEC = {
	shm_key = 0x1303,
	header  = "examples/msg_db_stats.h",
	struct  = "DB_STATS.data",
	header_struct = "DB_STATS_HEADER",
	count_field = "cur_cnt",
}

function M.update()
	-- render()에서 매 프레임 세 SHM을 새로 읽으므로 별도 갱신 불필요
end

function M.render(p)
	local recv = tapas.shmstruct_read(RECV_SPEC)
	local proc = tapas.shmstruct_read(PROC_SPEC)
	local db   = tapas.shmstruct_read(DB_SPEC)

	-- msg_code로 세 SHM을 합친다 (recv를 기준으로 시작해 처음 보는
	-- 코드가 나올 때마다 순서를 기록 — 등장 순서를 보존하기 위함).
	local by_code, order = {}, {}
	local function row_for(code)
		if not by_code[code] then
			by_code[code] = { recv_cnt = "0", proc_cnt = "0", db_cnt = "0" }
			table.insert(order, code)
		end
		return by_code[code]
	end
	for _, r in ipairs(recv) do row_for(r.msg_code).recv_cnt = r.recv_cnt end
	for _, r in ipairs(proc) do row_for(r.msg_code).proc_cnt = r.proc_cnt end
	for _, r in ipairs(db)   do row_for(r.msg_code).db_cnt   = r.db_cnt   end

	local rows = {}
	for _, code in ipairs(order) do
		local v = by_code[code]
		table.insert(rows, {
			code,
			{ value = v.recv_cnt, align = "right" },
			{ value = v.proc_cnt, align = "right" },
			{ value = v.db_cnt,   align = "right" },
		})
	end

	tapas.render_table(p, 1,
		{ "전문코드", "수신건수 (SHM_A)", "처리건수 (SHM_B)", "DB저장건수 (SHM_C)" },
		rows, 0, tapas.list_cols())  -- config.lua의 list_cols=N을 그대로 따른다
end

return M

-- MySQL 조회 뷰: mysql CLI를 io.popen()으로 실행해 결과를 표로 표시.
-- host에는 mysql CLI를 설치하지 않고, docker 컨테이너 안의 mysql 클라이언트를
-- `docker exec`로 그대로 호출한다. 접속정보/쿼리는 아래 값만 고치면 됨
-- (재빌드 불필요). 비밀번호는 커맨드라인 인자 대신 MYSQL_PWD 환경변수로
-- 넘겨 `ps aux` 노출을 막는다(단 /proc/pid/environ로는 여전히 보일 수 있음).
local common = dofile("lua/db/db_common.lua")

local container = "tapas-eye-demo-mysql"
local user       = "root"
local password   = ""
local database   = "test"
local query      = "SELECT isin, exec_prc, exec_qty, open_prc, high_prc, low_prc FROM koscom_stock_a3_test;"

local function build_cmd()
    return string.format(
        "docker exec -e MYSQL_PWD=%s %s mysql -u%s %s -B -e %s",
        common.shell_quote(password),
        common.shell_quote(container),
        common.shell_quote(user),
        common.shell_quote(database),
        common.shell_quote(query)
    )
end

return common.new_view({ build_cmd = build_cmd, sep = "\t", refresh_sec = 5 })

-- PostgreSQL 조회 뷰: psql CLI를 io.popen()으로 실행해 결과를 표로 표시.
-- 접속정보/쿼리는 아래 값만 고치면 됨 (재빌드 불필요). 비밀번호는 커맨드라인
-- 인자 대신 PGPASSWORD 환경변수로 넘긴다 — 더 안전한 대안은 ~/.pgpass.
--
-- 예제 쿼리는 examples/koscom_stock.h의 KOSCOM_STOCK_A0(코스피/코스닥/코넥스
-- 배치) 구조체 필드 중 일부(종목코드/한글약명/기준가/전일종가/상한가/하한가)를
-- 그대로 옮긴 테스트 테이블 koscom_stock_a0_test를 조회한다. 테이블/샘플
-- 데이터는 lua/db/db_postgresql_seed.sql로 만든다.
local common = dofile("lua/db/db_common.lua")

local host     = "127.0.0.1"
local port     = 5432
local user     = "postgres"
local password = ""
local database = "postgres"
local query    = "SELECT isin, kor_name, base_price, prev_close, upper_limit, lower_limit FROM koscom_stock_a0_test;"

local function build_cmd()
    return string.format(
        "PGPASSWORD=%s psql -h %s -p %s -U %s -d %s -A -F %s -c %s",
        common.shell_quote(password),
        common.shell_quote(host),
        tostring(port),
        common.shell_quote(user),
        common.shell_quote(database),
        common.shell_quote("|"),
        common.shell_quote(query)
    )
end

return common.new_view({ build_cmd = build_cmd, sep = "|", refresh_sec = 5 })

-- Altibase 조회 뷰: isql CLI를 io.popen()으로 실행해 결과를 표로 표시.
-- host에는 아무것도 설치하지 않고, docker 컨테이너(tapas-eye-demo-altibase,
-- altibase/a_plus_edition — 라이선스 없이 도는 무료 에디션) 안의 isql을
-- `docker exec`로 그대로 호출한다 — db_mysql.lua와 같은 패턴.
--
-- isql은 mysql -B / psql -A 같은 "구분자 출력" 옵션이 없다(고정폭 표 +
-- 헤더밑줄 + "N rows selected." 꼬리말만 지원). 그래서 두 가지로 우회한다:
--   1. `set heading off;`로 isql 자체 헤더/밑줄을 끄고, 진짜 헤더는 우리가
--      echo로 직접 앞에 붙인다.
--   2. 쿼리 자체에서 SELECT ... || '|' || ... 로 각 행을 이미 구분자로 이어
--      붙여서 내보낸다 — isql이 남기는 컬럼 우측 공백 패딩은 sed로 벗겨낸다.
-- 결과물은 mysql/psql이 내는 것과 같은 모양(헤더 줄 + 구분자로 나뉜 데이터
-- 줄 + "N rows selected.")이 되어 db_common.lua를 그대로 재사용할 수 있다.
--
-- 예제 쿼리는 examples/msg_db_stats.h의 DB_STATS_DATA(DB적재 프로세스가
-- 전문별로 남기는 DB저장 건수) 구조체 필드(전문코드/DB저장건수)를 그대로
-- 옮긴 테스트 테이블 msg_db_stats_test를 조회한다. 테이블/샘플 데이터는
-- lua/db/db_altibase_seed.sql로 만든다.
local common = dofile("lua/db/db_common.lua")

local container = "tapas-eye-demo-altibase"
local user       = "sys"
local password   = "manager"
local headers    = { "msg_code", "db_cnt" }
local query      = "SELECT msg_code || '|' || db_cnt FROM msg_db_stats_test;"

local function build_cmd()
    local isql_cmd = string.format(
        "$ALTIBASE_HOME/bin/isql -u %s -p %s -s localhost -silent -noprompt",
        user, password
    )
    return string.format(
        "{\necho %s\ndocker exec -i %s bash -lc %s <<'ALTIBASE_SQL'\nset heading off;\n%s\nquit;\nALTIBASE_SQL\n} | sed 's/[ \t]*$//'",
        common.shell_quote(table.concat(headers, "|")),
        common.shell_quote(container),
        common.shell_quote(isql_cmd),
        query
    )
end

return common.new_view({ build_cmd = build_cmd, sep = "|", refresh_sec = 5 })

-- DB 조회 공용 라이브러리. 각 DB의 CLI 클라이언트(mysql/psql/isql)를
-- io.popen()으로 실행해 stdout을 구분자 기반 표로 파싱, tapas.render_table()로
-- 표시한다. 새 C API나 재빌드 없이 db_*.lua 상단의 접속정보/쿼리만 고치면 된다.
local M = {}

-- 셸에 안전하게 넘기기 위한 작은따옴표 이스케이프 (셸 인젝션 방지)
function M.shell_quote(s)
    return "'" .. tostring(s):gsub("'", "'\\''") .. "'"
end

-- cmd를 실행해 stdout+stderr를 합쳐서 읽는다.
-- 성공: out, nil / 실패: nil, err(명령이 stderr에 남긴 메시지)
function M.run_capture(cmd)
    local f = io.popen(cmd .. " 2>&1")
    if not f then
        return nil, "명령 실행 실패: io.popen 실패"
    end
    local out = f:read("*a") or ""
    local ok = f:close()
    if not ok then
        local msg = out:gsub("%s+$", "")
        if msg == "" then msg = "명령 실행 실패 (종료 코드 비정상)" end
        return nil, msg
    end
    return out, nil
end

-- DB 클라이언트가 결과 뒤에 붙이는 꼬리말 줄(건수 요약 등)은 클라이언트
-- 종류/버전마다 문구가 달라서 고정 줄수 대신 패턴으로 걸러낸다.
local FOOTER_PATTERNS = {
    "^%(%d+ rows?%)%s*$",       -- psql -A
    "^%d+ rows? in set",        -- mysql
    "^%d+ rows? selected%.?%s*$", -- 여러 DB의 일반적인 "N rows selected."
}

local function is_footer(line)
    for _, pat in ipairs(FOOTER_PATTERNS) do
        if line:match(pat) then return true end
    end
    return false
end

-- 구분자 기반 표 출력(첫 줄=헤더)을 { columns }, { rows... }로 파싱.
-- 빈 줄/꼬리말 줄은 무시.
function M.parse_delimited(output, sep)
    local columns, rows = nil, {}
    for line in (output .. "\n"):gmatch("(.-)\n") do
        if line ~= "" and not is_footer(line) then
            local fields = {}
            for field in (line .. sep):gmatch("(.-)" .. sep) do
                fields[#fields + 1] = field
            end
            if not columns then
                columns = fields
            else
                rows[#rows + 1] = fields
            end
        end
    end
    return columns or {}, rows
end

-- opts.build_cmd() : 실행할 셸 커맨드 문자열을 매번 새로 만들어 반환
-- opts.sep         : 출력 구분자 (mysql -B는 "\t", psql -A -F는 "|" 등)
-- opts.refresh_sec : 재조회 주기(초), 기본 5 — 화면 갱신 틱마다가 아니라
--                    이 주기마다 한 번만 쿼리 실행(DB 연결 폭주 방지)
function M.new_view(opts)
    local V = {}
    local scroll = 0
    local page_size = 20
    local columns, rows = {}, {}
    local err = nil
    local last_refresh = 0
    local refresh_sec = opts.refresh_sec or 5

    local function refresh()
        local out, e = M.run_capture(opts.build_cmd())
        if e then
            err = e
            columns, rows = {}, {}
        else
            err = nil
            columns, rows = M.parse_delimited(out, opts.sep or "\t")
        end
    end

    function V.update()
        local now = os.time()
        if now - last_refresh >= refresh_sec then
            last_refresh = now
            refresh()
        end
    end

    function V.render(p)
        page_size = math.max(1, p.rows - 1)
        if err then
            tapas.render_table(p, 0, { "오류" }, {
                { { value = err:gsub("\n", " "), color = "danger" } },
            }, 0)
            return
        end
        if #columns == 0 then
            tapas.render_table(p, 0, { "상태" }, { { "데이터 없음" } }, 0)
            return
        end
        tapas.render_table(p, 0, columns, rows, scroll)
    end

    function V.handle_key(key)
        local new_scroll, handled = tapas.scroll_key(key, scroll, #rows, page_size)
        scroll = new_scroll
        return handled
    end

    return V
end

return M

-- "대시보드" 메뉴의 Lua 버전 — 왼쪽 config-only 항목(관리자가 config.lua
-- 메뉴 항목에 panels = {...}를 직접 적는 것)과 똑같은 3개 화면(시스템 상태/
-- 프로세스 목록/로그)을 나열한다.
--
-- update()/render() 같은 로직은 전혀 없다 — 이 파일이 하는 일은 config.lua의
-- panels = {...} 문법을 그대로 Lua 파일 하나에 옮겨 적는 것뿐이다.
return {
	panels = {
		{ label = "시스템 상태", view = "system" },
		{ label = "프로세스 목록", view = "process" },
		{ label = "로그", view = "log" },
		{
			label = "SHM 구조체",
			view = "manual_shmstruct_dashboard",
			shm_key = 0x1234,
			header = "examples/koscom_stock.h",
			struct = "KOSCOM_STOCK_A0",
			start_index = 3,
			orientation = "vertical",
			vertical_rows = 3,
		},
	},
}

/*
 * 특정 경로의 실제 여유 공간(GB)을 statvfs()로 직접 조회하는 라이브러리
 * 플러그인. Lua 표준 라이브러리(os/io)에는 이런 시스템 콜이 없어서 순수
 * Lua로는 만들 수 없다 — C로 짜서 require()로 불러 쓰는 게 tapas-eye
 * 확장의 핵심 패턴이다.
 *
 * 컴파일: plugins/build.sh disk_free
 * Lua에서 사용:
 *   local disk_free = require("disk_free")
 *   local gb = disk_free.gb("/")  -- 경로가 없으면 nil
 */
#include "tapas_plugin.h"
#include <sys/statvfs.h>

static int l_gb(lua_State *L) {
    const char *path = luaL_checkstring(L, 1);

    struct statvfs st;
    if (statvfs(path, &st) != 0) {
        lua_pushnil(L);
        return 1;
    }

    double free_bytes = (double)st.f_bsize * (double)st.f_bavail;
    lua_pushnumber(L, free_bytes / (1024.0 * 1024.0 * 1024.0));
    return 1;
}

static const luaL_Reg funcs[] = {
    {"gb", l_gb},
    {NULL, NULL}
};

int luaopen_disk_free(lua_State *L) {
    luaL_newlib(L, funcs);
    return 1;
}

-- require()로 불러오면 그 뒤로는 평범한 Lua 함수처럼 쓴다.
-- (plugins/*.so는 require()가 자동으로 찾는다 — package.cpath가
-- './plugins/?.so'를 이미 포함하도록 lua_conf.c가 설정해둔다.)
local disk_free = require("disk_free")

local M = {}

local PATHS = { "/", "/tmp", "/var" }

function M.update() end

function M.render(p)
	local rows = {}
	for _, path in ipairs(PATHS) do
		local gb = disk_free.gb(path)
		table.insert(rows, {
			name = path,
			value = gb and string.format("%.1f GB 여유", gb) or "경로 없음 (statvfs 실패)",
		})
	end
	tapas.render_kv(p, rows)
end

function M.handle_key(key) return false end

return M

#include "tapas_plugin.h"
#include <time.h>

static char s_time[32];
static int  s_tick = 0;

static int l_update(lua_State *L) {
    (void)L;
    time_t t = time(NULL);
    strftime(s_time, sizeof(s_time), "%Y-%m-%d %H:%M:%S", localtime(&t));
    s_tick++;
    return 0;
}

static int l_render(lua_State *L) {
    TapasPanel p = tapas_panel_from_lua(L, 1);

    tui_move(p.row + 1, p.col + 2);
    tui_color(TAPAS_CLR_HEADER);
    tui_puts("[ Example Plugin v1.0 ]");
    tui_clear_line();

    tui_move(p.row + 4, p.col + 4);
    tui_color(TAPAS_CLR_NORMAL);
    tui_printf("현재 시각  : %s", s_time);
    tui_clear_line();

    tui_color(TAPAS_CLR_RESET);
    return 0;
}

static const luaL_Reg funcs[] = {
    {"update", l_update}, {"render", l_render}, {NULL, NULL}
};

int luaopen_example_view(lua_State *L) {
    luaL_newlib(L, funcs);
    return 1;
}

#include "tapas_plugin.h"
#include <sys/ipc.h>
#include <sys/msg.h>

static int l_read(lua_State *L) {
    long key = (long)luaL_checkinteger(L, 1);

    int msqid = msgget((key_t)key, 0);
    if (msqid < 0) { lua_pushnil(L); return 1; }

    struct msqid_ds ds;
    if (msgctl(msqid, IPC_STAT, &ds) != 0) { lua_pushnil(L); return 1; }

    lua_pushinteger(L, (lua_Integer)ds.msg_qnum);
    return 1;
}

static const luaL_Reg funcs[] = { {"read", l_read}, {NULL, NULL} };

int luaopen_msgq_depth(lua_State *L) {
    luaL_newlib(L, funcs);
    return 1;
}