첫 번째 앱 구축

import asyncio
from ironflock import IronFlock
 
async def main():
    # 이 디바이스를 온라인으로 등록
    await flock.append_to_table("devices", {
        "device_key": os.environ.get('DEVICE_KEY'),
        "tsp": now,
        "status": "online",
        "device_name": os.environ.get('DEVICE_NAME'),
        "deleted": False
    })
 
    # ... 나머지 로직
 
flock = IronFlock(mainFunc=main)
flock.run()

import { IronFlock } from "ironflock";
 
const flock = new IronFlock();
await flock.start();
 
// 이 디바이스를 온라인으로 등록
await flock.appendToTable("devices", [{
    device_key: process.env.DEVICE_KEY,
    tsp: new Date().toISOString(),
    status: "online",
    device_name: process.env.DEVICE_NAME,
    deleted: false
}]);

async def main():
    # ... 디바이스 등록 ...
 
    # 기존 Modbus 서버 읽기
    existing = await flock.getHistory("modbus_servers", {
        "limit": 1000,
        "filterAnd": [
            # "latest": True는 server_id별 최신 행만 반환합니다
            {"latest": True},
            {"column": "deleted", "operator": "IS", "value": None}
        ]
    })
    for server in existing:
        create_modbus_connection(server)
 
    # 실시간으로 새 서버에 반응
    def on_server_change(*args, **kwargs):
        server = args[0] if args else kwargs
        if server.get("deleted"):
            delete_modbus_connection(server["server_id"])
        else:
            create_modbus_connection(server)
 
    await flock.subscribe_to_table("modbus_servers", on_server_change)

// 기존 Modbus 서버 읽기
const existing = await flock.getHistory("modbus_servers", {
    limit: 1000,
    filterAnd: [
        // latest: true는 server_id별 최신 행만 반환합니다
        { latest: true },
        { column: "deleted", operator: "IS", value: null }
    ]
});
existing.forEach(server => createModbusConnection(server));
 
// 실시간으로 새 서버에 반응
await flock.subscribeToTable("modbus_servers", (...args) => {
    const server = args[0];
    if (server.deleted) {
        deleteModbusConnection(server.server_id);
    } else {
        createModbusConnection(server);
    }
});

async def modbus_poll_loop(server_id, client):
    while True:
        values = client.read_registers()
        for metric, value in values.items():
            await flock.publish_to_table("readings", {
                "server_id": server_id,
                "metric": metric,
                "value": value
            })
        await asyncio.sleep(5)

async function modbusPollingLoop(serverId, client) {
    setInterval(async () => {
        const values = client.readRegisters();
        for (const [metric, value] of Object.entries(values)) {
            await flock.publishToTable("readings", [{
                server_id: serverId,
                metric,
                value
            }]);
        }
    }, 5000);
}