İşlem Öncesi Risk ve Kill Switch — Strateji Durmadan Emir Yağdırırsa?

1
package com.bank.risk;
2

3
import java.util.Optional;
4

5
public interface RiskCheck {
6

7
    /** Empty when the order may pass; otherwise the reason it may not. */
8
    Optional<String> reject(NewOrder order, Exposure exposure);
9

10
    static RiskCheck maxOrderQty(long max) {
11
        return (order, exposure) -> order.quantity() > max
12
            ? Optional.of("order quantity " + order.quantity() + " above " + max)
13
            : Optional.empty();
14
    }
15

16
    static RiskCheck maxPosition(long max) {
17
        return (order, exposure) -> exposure.positionAfter(order) > max
18
            ? Optional.of("position would reach " + exposure.positionAfter(order))
19
            : Optional.empty();
20
    }
21
}

1
package com.bank.risk;
2

3
public final class KillSwitch {
4

5
    private final KillSwitchStore store; // a table row, not a field: survives restarts
6

7
    public KillSwitch(KillSwitchStore store) {
8
        this.store = store;
9
    }
10

11
    public boolean isEngaged(String strategyId) {
12
        return store.isEngaged(strategyId);
13
    }
14

15
    public void engage(String strategyId, String reason) {
16
        store.engage(strategyId, reason);
17
    }
18

19
    /** Only a person re-enables a strategy, and it is recorded who did. */
20
    public void release(String strategyId, String operator) {
21
        store.release(strategyId, operator);
22
    }
23
}

1
package com.bank.risk;
2

3
import java.util.List;
4
import java.util.Optional;
5

6
public final class RiskGateway {
7

8
    private static final int REPEAT_LIMIT = 3;
9

10
    private final KillSwitch killSwitch;
11
    private final List<RiskCheck> checks;
12
    private final ExchangeSession exchange;
13
    private final RepeatDetector repeats = new RepeatDetector(REPEAT_LIMIT);
14

15
    public RiskGateway(KillSwitch killSwitch, List<RiskCheck> checks, ExchangeSession exchange) {
16
        this.killSwitch = killSwitch;
17
        this.checks = List.copyOf(checks);
18
        this.exchange = exchange;
19
    }
20

21
    public Decision submit(NewOrder order, Exposure exposure) {
22
        if (killSwitch.isEngaged(order.strategyId())) {
23
            return Decision.rejected("strategy stopped");
24
        }
25
        if (repeats.isRunaway(order)) {
26
            killSwitch.engage(order.strategyId(), "identical orders in a row");
27
            return Decision.rejected("strategy stopped: runaway pattern");
28
        }
29
        for (RiskCheck check : checks) {
30
            Optional<String> reason = check.reject(order, exposure);
31
            if (reason.isPresent()) {
32
                return Decision.rejected(reason.get());
33
            }
34
        }
35
        exchange.send(order);
36
        return Decision.sent();
37
    }
38
}