feat(device): implement adapter registry and discovery

yeg

2026-08-26 e12439d1f4a94957d68cda653cb666702bc71040

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
package com.ruoyi.device.registry;
 
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.assertNotSame;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;
import org.junit.jupiter.api.Test;
import com.ruoyi.device.api.DeviceAdapter;
import com.ruoyi.device.model.AdapterCapabilities;
import com.ruoyi.device.model.ChannelIdentity;
import com.ruoyi.device.model.DeviceControlCommand;
 
class DeviceAdapterRegistryTest
{
    @Test
    void synchronizesEnabledConfigurationWithoutRecreatingUnchangedAdapter()
    {
        RecordingFactory factory = new RecordingFactory();
        try (DeviceAdapterRegistry registry = new DeviceAdapterRegistry(List.of(factory)))
        {
            AdapterInstanceConfig config = config("127.0.0.1", true);
 
            registry.synchronize(config);
            DeviceAdapter first = registry.require("lab-bts");
            registry.synchronize(config);
 
            assertSame(first, registry.require("lab-bts"));
            assertFalse(factory.adapters.get(0).closed.get());
        }
    }
 
    @Test
    void replacesChangedConfigurationAndClosesAdapterWhenDisabled()
    {
        RecordingFactory factory = new RecordingFactory();
        try (DeviceAdapterRegistry registry = new DeviceAdapterRegistry(List.of(factory)))
        {
            registry.synchronize(config("127.0.0.1", true));
            StubAdapter first = factory.adapters.get(0);
 
            registry.synchronize(config("127.0.0.2", true));
 
            assertTrue(first.closed.get());
            assertNotSame(first, registry.require("lab-bts"));
 
            registry.synchronize(config("127.0.0.2", false));
 
            assertTrue(factory.adapters.get(1).closed.get());
            assertFalse(registry.contains("lab-bts"));
            assertThrows(AdapterRegistryException.class, () -> registry.require("lab-bts"));
        }
    }
 
    private static AdapterInstanceConfig config(String host, boolean enabled)
    {
        return new AdapterInstanceConfig("lab-bts", "BTS", host, 502, 5000,
                "Asia/Hong_Kong", enabled, AdapterCapabilities.observeOnly());
    }
 
    private static final class RecordingFactory implements DeviceAdapterFactory
    {
        private final List<StubAdapter> adapters = new ArrayList<>();
 
        @Override
        public String adapterType()
        {
            return "BTS";
        }
 
        @Override
        public DeviceAdapter create(AdapterInstanceConfig config)
        {
            StubAdapter adapter = new StubAdapter(config.adapterCode());
            adapters.add(adapter);
            return adapter;
        }
    }
 
    private static final class StubAdapter implements DeviceAdapter
    {
        private final String code;
        private final AtomicBoolean closed = new AtomicBoolean();
 
        private StubAdapter(String code)
        {
            this.code = code;
        }
 
        @Override
        public String adapterCode()
        {
            return code;
        }
 
        @Override
        public AdapterCapabilities capabilities()
        {
            return AdapterCapabilities.observeOnly();
        }
 
        @Override
        public List<com.ruoyi.device.model.DetectedChannel> discoverChannels()
        {
            return List.of();
        }
 
        @Override
        public java.util.Map<ChannelIdentity, com.ruoyi.device.model.RealtimeSnapshot> inquire(
                java.util.Set<ChannelIdentity> channels)
        {
            return java.util.Map.of();
        }
 
        @Override
        public List<com.ruoyi.device.model.HistoryAvailability> inquireHistory(
                java.util.Set<ChannelIdentity> channels)
        {
            return List.of();
        }
 
        @Override
        public com.ruoyi.device.model.HistoryPage downloadHistory(ChannelIdentity channel,
                String btsTestId, long startPosition, int limit)
        {
            throw new UnsupportedOperationException();
        }
 
        @Override
        public void control(ChannelIdentity channel, DeviceControlCommand command)
        {
            throw new UnsupportedOperationException();
        }
 
        @Override
        public void close()
        {
            closed.set(true);
        }
    }
}