1 /* 2 * Copyright 2018 The gRPC Authors 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package io.grpc; 18 19 import static com.google.common.truth.Truth.assertThat; 20 import static io.grpc.InternalChannelz.id; 21 import static junit.framework.TestCase.assertTrue; 22 import static org.junit.Assert.assertEquals; 23 import static org.junit.Assert.assertFalse; 24 import static org.junit.Assert.assertNotNull; 25 import static org.junit.Assert.assertNull; 26 import static org.junit.Assert.assertSame; 27 import static org.mockito.Mockito.mock; 28 import static org.mockito.Mockito.when; 29 30 import com.google.common.util.concurrent.ListenableFuture; 31 import io.grpc.InternalChannelz.ChannelStats; 32 import io.grpc.InternalChannelz.RootChannelList; 33 import io.grpc.InternalChannelz.ServerList; 34 import io.grpc.InternalChannelz.ServerSocketsList; 35 import io.grpc.InternalChannelz.ServerStats; 36 import io.grpc.InternalChannelz.SocketStats; 37 import io.grpc.InternalChannelz.Tls; 38 import java.security.cert.Certificate; 39 import javax.net.ssl.SSLSession; 40 import org.junit.Test; 41 import org.junit.runner.RunWith; 42 import org.junit.runners.JUnit4; 43 44 @RunWith(JUnit4.class) 45 public final class InternalChannelzTest { 46 47 private final InternalChannelz channelz = new InternalChannelz(); 48 49 @Test getRootChannels_empty()50 public void getRootChannels_empty() { 51 RootChannelList rootChannels = channelz.getRootChannels(/*fromId=*/ 0, /*maxPageSize=*/ 1); 52 assertTrue(rootChannels.end); 53 assertThat(rootChannels.channels).isEmpty(); 54 } 55 56 @Test getRootChannels_onePage()57 public void getRootChannels_onePage() { 58 InternalInstrumented<ChannelStats> root1 = create(); 59 channelz.addRootChannel(root1); 60 RootChannelList page = channelz.getRootChannels(/*fromId=*/ 0, /*maxPageSize=*/ 1); 61 assertTrue(page.end); 62 assertThat(page.channels).containsExactly(root1); 63 } 64 65 @Test getRootChannels_onePage_multi()66 public void getRootChannels_onePage_multi() { 67 InternalInstrumented<ChannelStats> root1 = create(); 68 InternalInstrumented<ChannelStats> root2 = create(); 69 channelz.addRootChannel(root1); 70 channelz.addRootChannel(root2); 71 RootChannelList page = channelz.getRootChannels(/*fromId=*/ 0, /*maxPageSize=*/ 2); 72 assertTrue(page.end); 73 assertThat(page.channels).containsExactly(root1, root2); 74 } 75 76 @Test getRootChannels_paginate()77 public void getRootChannels_paginate() { 78 InternalInstrumented<ChannelStats> root1 = create(); 79 InternalInstrumented<ChannelStats> root2 = create(); 80 channelz.addRootChannel(root1); 81 channelz.addRootChannel(root2); 82 RootChannelList page1 = channelz.getRootChannels(/*fromId=*/ 0, /*maxPageSize=*/ 1); 83 assertFalse(page1.end); 84 assertThat(page1.channels).containsExactly(root1); 85 RootChannelList page2 86 = channelz.getRootChannels(/*fromId=*/ id(root1) + 1, /*maxPageSize=*/ 1); 87 assertTrue(page2.end); 88 assertThat(page2.channels).containsExactly(root2); 89 } 90 91 @Test getRootChannels_remove()92 public void getRootChannels_remove() { 93 InternalInstrumented<ChannelStats> root1 = create(); 94 channelz.addRootChannel(root1); 95 channelz.removeRootChannel(root1); 96 RootChannelList page = channelz.getRootChannels(/*fromId=*/ 0, /*maxPageSize=*/ 1); 97 assertTrue(page.end); 98 assertThat(page.channels).isEmpty(); 99 } 100 101 @Test getRootChannels_addAfterLastPage()102 public void getRootChannels_addAfterLastPage() { 103 InternalInstrumented<ChannelStats> root1 = create(); 104 { 105 channelz.addRootChannel(root1); 106 RootChannelList page1 = channelz.getRootChannels(/*fromId=*/ 0, /*maxPageSize=*/ 1); 107 assertTrue(page1.end); 108 assertThat(page1.channels).containsExactly(root1); 109 } 110 111 InternalInstrumented<ChannelStats> root2 = create(); 112 { 113 channelz.addRootChannel(root2); 114 RootChannelList page2 115 = channelz.getRootChannels(/*fromId=*/ id(root1) + 1, /*maxPageSize=*/ 1); 116 assertTrue(page2.end); 117 assertThat(page2.channels).containsExactly(root2); 118 } 119 } 120 121 @Test getServers_empty()122 public void getServers_empty() { 123 ServerList servers = channelz.getServers(/*fromId=*/ 0, /*maxPageSize=*/ 1); 124 assertTrue(servers.end); 125 assertThat(servers.servers).isEmpty(); 126 } 127 128 @Test getServers_onePage()129 public void getServers_onePage() { 130 InternalInstrumented<ServerStats> server1 = create(); 131 channelz.addServer(server1); 132 ServerList page = channelz.getServers(/*fromId=*/ 0, /*maxPageSize=*/ 1); 133 assertTrue(page.end); 134 assertThat(page.servers).containsExactly(server1); 135 } 136 137 @Test getServers_onePage_multi()138 public void getServers_onePage_multi() { 139 InternalInstrumented<ServerStats> server1 = create(); 140 InternalInstrumented<ServerStats> server2 = create(); 141 channelz.addServer(server1); 142 channelz.addServer(server2); 143 ServerList page = channelz.getServers(/*fromId=*/ 0, /*maxPageSize=*/ 2); 144 assertTrue(page.end); 145 assertThat(page.servers).containsExactly(server1, server2); 146 } 147 148 @Test getServers_paginate()149 public void getServers_paginate() { 150 InternalInstrumented<ServerStats> server1 = create(); 151 InternalInstrumented<ServerStats> server2 = create(); 152 channelz.addServer(server1); 153 channelz.addServer(server2); 154 ServerList page1 = channelz.getServers(/*fromId=*/ 0, /*maxPageSize=*/ 1); 155 assertFalse(page1.end); 156 assertThat(page1.servers).containsExactly(server1); 157 ServerList page2 158 = channelz.getServers(/*fromId=*/ id(server1) + 1, /*maxPageSize=*/ 1); 159 assertTrue(page2.end); 160 assertThat(page2.servers).containsExactly(server2); 161 } 162 163 @Test getServers_remove()164 public void getServers_remove() { 165 InternalInstrumented<ServerStats> server1 = create(); 166 channelz.addServer(server1); 167 channelz.removeServer(server1); 168 ServerList page = channelz.getServers(/*fromId=*/ 0, /*maxPageSize=*/ 1); 169 assertTrue(page.end); 170 assertThat(page.servers).isEmpty(); 171 } 172 173 @Test getServers_addAfterLastPage()174 public void getServers_addAfterLastPage() { 175 InternalInstrumented<ServerStats> server1 = create(); 176 { 177 channelz.addServer(server1); 178 ServerList page = channelz.getServers(/*fromId=*/ 0, /*maxPageSize=*/ 1); 179 assertTrue(page.end); 180 assertThat(page.servers).containsExactly(server1); 181 } 182 183 InternalInstrumented<ServerStats> server2 = create(); 184 { 185 channelz.addServer(server2); 186 ServerList page 187 = channelz.getServers(/*fromId=*/ id(server1) + 1, /*maxPageSize=*/ 1); 188 assertTrue(page.end); 189 assertThat(page.servers).containsExactly(server2); 190 } 191 } 192 193 @Test getChannel()194 public void getChannel() { 195 InternalInstrumented<ChannelStats> root = create(); 196 assertNull(channelz.getChannel(id(root))); 197 198 channelz.addRootChannel(root); 199 assertSame(root, channelz.getChannel(id(root))); 200 assertNull(channelz.getSubchannel(id(root))); 201 202 channelz.removeRootChannel(root); 203 assertNull(channelz.getRootChannel(id(root))); 204 } 205 206 @Test getSubchannel()207 public void getSubchannel() { 208 InternalInstrumented<ChannelStats> sub = create(); 209 assertNull(channelz.getSubchannel(id(sub))); 210 211 channelz.addSubchannel(sub); 212 assertSame(sub, channelz.getSubchannel(id(sub))); 213 assertNull(channelz.getChannel(id(sub))); 214 215 channelz.removeSubchannel(sub); 216 assertNull(channelz.getSubchannel(id(sub))); 217 } 218 219 @Test getSocket()220 public void getSocket() { 221 InternalInstrumented<SocketStats> socket = create(); 222 assertNull(channelz.getSocket(id(socket))); 223 224 channelz.addClientSocket(socket); 225 assertSame(socket, channelz.getSocket(id(socket))); 226 227 channelz.removeClientSocket(socket); 228 assertNull(channelz.getSocket(id(socket))); 229 } 230 231 @Test serverSocket_noServer()232 public void serverSocket_noServer() { 233 assertNull(channelz.getServerSockets(/*serverId=*/ 1, /*fromId=*/0, /*maxPageSize=*/ 1)); 234 } 235 236 @Test serverSocket()237 public void serverSocket() { 238 InternalInstrumented<ServerStats> server = create(); 239 channelz.addServer(server); 240 241 InternalInstrumented<SocketStats> socket = create(); 242 assertEmptyServerSocketsPage(id(server), id(socket)); 243 244 channelz.addServerSocket(server, socket); 245 ServerSocketsList page 246 = channelz.getServerSockets(id(server), id(socket), /*maxPageSize=*/ 1); 247 assertNotNull(page); 248 assertTrue(page.end); 249 assertThat(page.sockets).containsExactly(socket); 250 251 channelz.removeServerSocket(server, socket); 252 assertEmptyServerSocketsPage(id(server), id(socket)); 253 } 254 255 @Test serverSocket_eachServerSeparate()256 public void serverSocket_eachServerSeparate() { 257 InternalInstrumented<ServerStats> server1 = create(); 258 InternalInstrumented<ServerStats> server2 = create(); 259 260 InternalInstrumented<SocketStats> socket1 = create(); 261 InternalInstrumented<SocketStats> socket2 = create(); 262 263 channelz.addServer(server1); 264 channelz.addServer(server2); 265 channelz.addServerSocket(server1, socket1); 266 channelz.addServerSocket(server2, socket2); 267 268 ServerSocketsList list1 269 = channelz.getServerSockets(id(server1), /*fromId=*/ 0, /*maxPageSize=*/ 2); 270 assertNotNull(list1); 271 assertTrue(list1.end); 272 assertThat(list1.sockets).containsExactly(socket1); 273 274 ServerSocketsList list2 275 = channelz.getServerSockets(id(server2), /*fromId=*/ 0, /*maxPageSize=*/2); 276 assertNotNull(list2); 277 assertTrue(list2.end); 278 assertThat(list2.sockets).containsExactly(socket2); 279 } 280 281 @Test tlsSecurityInfo()282 public void tlsSecurityInfo() throws Exception { 283 Certificate local = io.grpc.internal.testing.TestUtils.loadX509Cert("client.pem"); 284 Certificate remote = io.grpc.internal.testing.TestUtils.loadX509Cert("server0.pem"); 285 final SSLSession session = mock(SSLSession.class); 286 when(session.getCipherSuite()).thenReturn("TLS_NULL_WITH_NULL_NULL"); 287 when(session.getLocalCertificates()).thenReturn(new Certificate[]{local}); 288 when(session.getPeerCertificates()).thenReturn(new Certificate[]{remote}); 289 290 Tls tls = new Tls(session); 291 assertEquals(local, tls.localCert); 292 assertEquals(remote, tls.remoteCert); 293 assertEquals("TLS_NULL_WITH_NULL_NULL", tls.cipherSuiteStandardName); 294 } 295 assertEmptyServerSocketsPage(long serverId, long socketId)296 private void assertEmptyServerSocketsPage(long serverId, long socketId) { 297 ServerSocketsList emptyPage 298 = channelz.getServerSockets(serverId, socketId, /*maxPageSize=*/ 1); 299 assertNotNull(emptyPage); 300 assertTrue(emptyPage.end); 301 assertThat(emptyPage.sockets).isEmpty(); 302 } 303 create()304 private static <T> InternalInstrumented<T> create() { 305 return new InternalInstrumented<T>() { 306 final InternalLogId id = InternalLogId.allocate("fake-type", /*details=*/ null); 307 @Override 308 public ListenableFuture<T> getStats() { 309 throw new UnsupportedOperationException(); 310 } 311 312 @Override 313 public InternalLogId getLogId() { 314 return id; 315 } 316 }; 317 } 318 } 319