JRuby로 브라우저에서 Ruby CLI 실행하기 — WebSocket 인터랙티브 터미널

브라우저 (coupler.html + coupler.js)
    │  WebSocket /ws/coupler
    ▼
CouplerWebSocketHandler (Spring WebSocket)
    │
    ├── afterConnectionEstablished()
    │       → Virtual Thread로 runScript() 실행
    │
    ├── handleTextMessage()
    │       → CouplerInputHelper.push(line)
    │               ↓ BlockingQueue
    │          Kernel#gets monkey-patch → Ruby gets() 반환
    │
    └── runScript()
            → new ScriptingContainer(SINGLETHREAD)
            → setOutput(WebSocketLineOutputStream)   ← stdout → WS 전송
            → setError(WebSocketLineOutputStream)    ← stderr → WS 전송
            → put("$coupler_input", inputHelper)
            → runScriptlet(GETS_PATCH)               ← gets() 오버라이드
            → runScriptlet(PathType.ABSOLUTE, path)  ← 스크립트 실행

// web/build.gradle.kts
dependencies {
    implementation("org.jruby:jruby:9.4.12.0")
}

container = new ScriptingContainer(LocalContextScope.SINGLETHREAD);
container.setCurrentDirectory(scriptPath);  // 스크립트의 require 기준 경로
container.setOutput(ps);   // stdout → WebSocket
container.setError(ps);    // stderr → WebSocket

public class WebSocketLineOutputStream extends OutputStream {
    private final WebSocketSession session;
    private final ReentrantLock lock;
    private final ByteArrayOutputStream buf = new ByteArrayOutputStream();

    @Override
    public void write(byte[] b, int off, int len) throws IOException {
        buf.write(b, off, len);
        flushLines();
    }

    private void flushLines() throws IOException {
        String chunk = buf.toString(StandardCharsets.UTF_8);
        int nl;
        while ((nl = chunk.indexOf('\n')) >= 0) {
            String line = chunk.substring(0, nl);
            sendLine(line);
            chunk = chunk.substring(nl + 1);
        }
        buf.reset();
        if (!chunk.isEmpty()) {
            buf.write(chunk.getBytes(StandardCharsets.UTF_8));
        }
    }
}

// 1차 시도 — PipedInputStream
PipedOutputStream pos = new PipedOutputStream();
PipedInputStream pis = new PipedInputStream(pos);
container.setInput(pis);
// → org.jruby.exceptions.SystemCallError: (EBADF) Bad file descriptor

// 2차 시도 — NIO Pipe
Pipe pipe = Pipe.open();
// → 동일하게 EBADF

// 3차 시도 — PipedReader + ReaderInputStream
// → java.io.IOException: Pipe broken

private static final String GETS_PATCH =
    "module Kernel\n" +
    "  def gets(*)\n" +
    "    result = $coupler_input.gets\n" +  // Java CouplerInputHelper 호출
    "    $_ = result\n" +
    "    result\n" +
    "  end\n" +
    "end\n";

// CouplerInputHelper.java
public class CouplerInputHelper {
    private static final String CLOSE_SENTINEL = "\u0000";
    private final LinkedBlockingQueue<String> queue = new LinkedBlockingQueue<>();
    private volatile boolean closed = false;

    // 브라우저에서 입력이 들어오면 WebSocket 핸들러가 호출
    public void push(String line) {
        if (!closed) queue.offer(line);
    }

    // Ruby의 gets()가 호출될 때 블로킹 대기
    public String gets() throws InterruptedException {
        String line = queue.take();  // 입력이 올 때까지 블로킹
        if (CLOSE_SENTINEL.equals(line)) return null;
        return line + "\n";  // Ruby의 gets() 관례: 개행 포함 반환
    }

    // 연결 종료 시 블로킹 해제
    public void close() {
        closed = true;
        queue.offer(CLOSE_SENTINEL);
    }
}

브라우저에서 Enter 입력
    │  WebSocket TextMessage
    ▼
handleTextMessage() → inputHelper.push("홍길동")
                                    ↓ LinkedBlockingQueue
Ruby 스크립트 내 gets() 호출
    → Kernel#gets monkey-patch 발동
    → $coupler_input.gets() (Java 메서드 호출)
    → queue.take() 블로킹 해제
    → "홍길동\n" 반환

if __FILE__ == $PROGRAM_NAME
  RandomCoupler.new.run
end

container.runScriptlet(GETS_PATCH);              // gets() 오버라이드 먼저
container.runScriptlet(PathType.ABSOLUTE, scriptAbsPath);  // 스크립트 실행
// 명시적인 RandomCoupler.new.run 호출 금지 — 가드가 자동으로 한 번만 실행함

private void terminateContainer(ScriptingContainer container, String sessionId) {
    if (container == null) return;
    final Thread t = Thread.ofVirtual()
            .name("coupler-term-" + sessionId.substring(0, 8))
            .start(() -> {
                try { container.terminate(); }
                catch (Exception ignored) {}
            });
    try {
        t.join(3_000);  // 최대 3초 대기
    } catch (InterruptedException ie) {
        Thread.currentThread().interrupt();
    }
    if (t.isAlive()) {
        log.warn("[CouplerWS] container.terminate() timed out (>3s), abandoned — session={}", sessionId);
    }
    // t.join() 이후 흐름은 항상 도달 — closeQuietly() 보장
}

private void cleanup(WebSocketSession session) {
    activeCount.decrementAndGet();

    // ① JRuby 런타임 종료 → runScriptlet() 블로킹 강제 해제
    final ScriptingContainer container =
        (ScriptingContainer) session.getAttributes().remove(ATTR_CONTAINER);
    terminateContainer(container, session.getId());

    // ② gets() 블로킹 해제 (CLOSE_SENTINEL 주입)
    final CouplerInputHelper helper =
        (CouplerInputHelper) session.getAttributes().remove(ATTR_INPUT);
    if (helper != null) helper.close();

    // ③ 보조 수단 (I/O 대기 등 일부 케이스)
    final Thread t = (Thread) session.getAttributes().remove(ATTR_THREAD);
    if (t != null && t.isAlive()) t.interrupt();
}

private static final int MAX_SESSIONS = 10;
private final AtomicInteger activeCount = new AtomicInteger(0);

@Override
public void afterConnectionEstablished(WebSocketSession session) throws IOException {
    if (activeCount.incrementAndGet() > MAX_SESSIONS) {
        activeCount.decrementAndGet();
        session.close(CloseStatus.SERVICE_OVERLOAD);
        return;
    }
    // ...
}

private void cleanup(WebSocketSession session) {
    activeCount.decrementAndGet();  // 반드시 cleanup에서 감소 (누락 시 MAX_SESSIONS 영구 도달)
    // ...
}

private static final int MAX_INPUT_LENGTH = 100;
// 백틱, 파이프, 세미콜론, 앰퍼샌드, 리다이렉트, 이스케이프, 변수 치환 차단
private static final Pattern DANGEROUS_PATTERN =
    Pattern.compile("[`|;&<>\\\\]|\\$[({]");

private String validateInput(String input) {
    if (input == null) return "null input";
    if (input.length() > MAX_INPUT_LENGTH)
        return "input too long (max " + MAX_INPUT_LENGTH + " chars)";
    if (DANGEROUS_PATTERN.matcher(input).find())
        return "disallowed characters detected";
    return null;
}

// setAllowedOrigins("*") 대신 명시적 도메인 지정
registry.addHandler(couplerWebSocketHandler, "/ws/coupler")
        .setAllowedOrigins(allowedOrigins);  // application.yml에서 주입

# application.yml
websocket:
  allowed-origins:
    - https://furaiki-lifelog.com
    - https://www.furaiki-lifelog.com
    - http://localhost:8080

# application-live.yml (운영: localhost 제거)
websocket:
  allowed-origins:
    - https://furaiki-lifelog.com
    - https://www.furaiki-lifelog.com

@Configuration
public class RubyConfig {

    private static final Logger log = LoggerFactory.getLogger(RubyConfig.class);

    @Bean
    public ApplicationRunner jrubyWarmUp() {
        return args -> Thread.ofVirtual().name("jruby-warmup").start(() -> {
            log.info("[JRuby] Starting warm-up — pre-initializing JRuby runtime");
            try {
                ScriptingContainer c = new ScriptingContainer(LocalContextScope.SINGLETHREAD);
                c.runScriptlet("1 + 1");  // 최소한의 실행으로 런타임 초기화 유발
                c.terminate();
                log.info("[JRuby] Warm-up completed successfully");
            } catch (Exception e) {
                log.warn("[JRuby] Warm-up failed — first session may experience startup delay", e);
            }
        });
    }
}

let socket = null;
let endedCleanly = false;  // /quit 등 정상 종료 후 재연결 방지 플래그

function connect() {
    const wsUrl = `wss://${location.host}/ws/coupler`;
    socket = new WebSocket(wsUrl);

    socket.onmessage = (e) => {
        const msg = e.data;
        if (msg === '__DONE__') {
            endedCleanly = true;
            setStatus('done', 'Done');
            return;
        }
        if (msg.startsWith('__ERROR__')) {
            appendLine(msg, 'cl-error');
            return;
        }
        appendLine(msg);
    };

    socket.onclose = () => {
        if (!endedCleanly) {
            // 비정상 종료 시 재연결 시도
            setTimeout(connect, 3000);
        }
    };
}

function sendInput() {
    const input = document.getElementById('console-input');
    if (socket && socket.readyState === WebSocket.OPEN) {
        appendLine('$ ' + input.value, 'cl-echo');
        socket.send(input.value);
        input.value = '';
    }
}