Examples with SocketStats io.grpc.InternalChannelz.SocketStats used on opensource projects

Example 6 with SocketStats

use of io.grpc.InternalChannelz.SocketStats in project grpc-java by grpc.

the class ChannelzProtoUtilTest method toServer.

@Test
public void toServer() throws Exception {
    // no listen sockets
    assertEquals(serverProto, ChannelzProtoUtil.toServer(server));
    // 1 listen socket
    server.serverStats = toBuilder(server.serverStats).addListenSockets(ImmutableList.<InternalInstrumented<SocketStats>>of(listenSocket)).build();
    assertEquals(serverProto.toBuilder().addListenSocket(listenSocketRef).build(), ChannelzProtoUtil.toServer(server));
    // multiple listen sockets
    TestListenSocket otherListenSocket = new TestListenSocket();
    SocketRef otherListenSocketRef = ChannelzProtoUtil.toSocketRef(otherListenSocket);
    server.serverStats = toBuilder(server.serverStats).addListenSockets(ImmutableList.<InternalInstrumented<SocketStats>>of(otherListenSocket)).build();
    assertEquals(serverProto.toBuilder().addListenSocket(listenSocketRef).addListenSocket(otherListenSocketRef).build(), ChannelzProtoUtil.toServer(server));
}

Example 7 with SocketStats

use of io.grpc.InternalChannelz.SocketStats in project grpc-java by grpc.

the class InternalChannelzTest method serverSocket_eachServerSeparate.

@Test
public void serverSocket_eachServerSeparate() {
    InternalInstrumented<ServerStats> server1 = create();
    InternalInstrumented<ServerStats> server2 = create();
    InternalInstrumented<SocketStats> socket1 = create();
    InternalInstrumented<SocketStats> socket2 = create();
    channelz.addServer(server1);
    channelz.addServer(server2);
    channelz.addServerSocket(server1, socket1);
    channelz.addServerSocket(server2, socket2);
    ServerSocketsList list1 = channelz.getServerSockets(id(server1), /*fromId=*/
    0, /*maxPageSize=*/
    2);
    assertNotNull(list1);
    assertTrue(list1.end);
    assertThat(list1.sockets).containsExactly(socket1);
    ServerSocketsList list2 = channelz.getServerSockets(id(server2), /*fromId=*/
    0, /*maxPageSize=*/
    2);
    assertNotNull(list2);
    assertTrue(list2.end);
    assertThat(list2.sockets).containsExactly(socket2);
}

Example 8 with SocketStats

use of io.grpc.InternalChannelz.SocketStats in project grpc-java by grpc.

the class InternalChannelzTest method serverSocket.

@Test
public void serverSocket() {
    InternalInstrumented<ServerStats> server = create();
    channelz.addServer(server);
    InternalInstrumented<SocketStats> socket = create();
    assertEmptyServerSocketsPage(id(server), id(socket));
    channelz.addServerSocket(server, socket);
    ServerSocketsList page = channelz.getServerSockets(id(server), id(socket), /*maxPageSize=*/
    1);
    assertNotNull(page);
    assertTrue(page.end);
    assertThat(page.sockets).containsExactly(socket);
    channelz.removeServerSocket(server, socket);
    assertEmptyServerSocketsPage(id(server), id(socket));
}

Example 9 with SocketStats

use of io.grpc.InternalChannelz.SocketStats in project grpc-java by grpc.

the class NettyServer method start.

@Override
public void start(ServerListener serverListener) throws IOException {
    listener = checkNotNull(serverListener, "serverListener");
    final ServerBootstrap b = new ServerBootstrap();
    b.option(ALLOCATOR, Utils.getByteBufAllocator(forceHeapBuffer));
    b.childOption(ALLOCATOR, Utils.getByteBufAllocator(forceHeapBuffer));
    b.group(bossExecutor, workerGroup);
    b.channelFactory(channelFactory);
    // For non-socket based channel, the option will be ignored.
    b.childOption(SO_KEEPALIVE, true);
    if (channelOptions != null) {
        for (Map.Entry<ChannelOption<?>, ?> entry : channelOptions.entrySet()) {
            @SuppressWarnings("unchecked") ChannelOption<Object> key = (ChannelOption<Object>) entry.getKey();
            b.option(key, entry.getValue());
        }
    }
    if (childChannelOptions != null) {
        for (Map.Entry<ChannelOption<?>, ?> entry : childChannelOptions.entrySet()) {
            @SuppressWarnings("unchecked") ChannelOption<Object> key = (ChannelOption<Object>) entry.getKey();
            b.childOption(key, entry.getValue());
        }
    }
    b.childHandler(new ChannelInitializer<Channel>() {

        @Override
        public void initChannel(Channel ch) {
            ChannelPromise channelDone = ch.newPromise();
            long maxConnectionAgeInNanos = NettyServer.this.maxConnectionAgeInNanos;
            if (maxConnectionAgeInNanos != MAX_CONNECTION_AGE_NANOS_DISABLED) {
                // apply a random jitter of +/-10% to max connection age
                maxConnectionAgeInNanos = (long) ((.9D + Math.random() * .2D) * maxConnectionAgeInNanos);
            }
            NettyServerTransport transport = new NettyServerTransport(ch, channelDone, protocolNegotiator, streamTracerFactories, transportTracerFactory.create(), maxStreamsPerConnection, autoFlowControl, flowControlWindow, maxMessageSize, maxHeaderListSize, keepAliveTimeInNanos, keepAliveTimeoutInNanos, maxConnectionIdleInNanos, maxConnectionAgeInNanos, maxConnectionAgeGraceInNanos, permitKeepAliveWithoutCalls, permitKeepAliveTimeInNanos, eagAttributes);
            ServerTransportListener transportListener;
            // This is to order callbacks on the listener, not to guard access to channel.
            synchronized (NettyServer.this) {
                if (terminated) {
                    // Server already terminated.
                    ch.close();
                    return;
                }
                // `channel` shutdown can race with `ch` initialization, so this is only safe to increment
                // inside the lock.
                sharedResourceReferenceCounter.retain();
                transportListener = listener.transportCreated(transport);
            }
            /**
             * Releases the event loop if the channel is "done", possibly due to the channel closing.
             */
            final class LoopReleaser implements ChannelFutureListener {

                private boolean done;

                @Override
                public void operationComplete(ChannelFuture future) throws Exception {
                    if (!done) {
                        done = true;
                        sharedResourceReferenceCounter.release();
                    }
                }
            }
            transport.start(transportListener);
            ChannelFutureListener loopReleaser = new LoopReleaser();
            channelDone.addListener(loopReleaser);
            ch.closeFuture().addListener(loopReleaser);
        }
    });
    Future<Map<ChannelFuture, SocketAddress>> bindCallFuture = bossExecutor.submit(new Callable<Map<ChannelFuture, SocketAddress>>() {

        @Override
        public Map<ChannelFuture, SocketAddress> call() {
            Map<ChannelFuture, SocketAddress> bindFutures = new HashMap<>();
            for (SocketAddress address : addresses) {
                ChannelFuture future = b.bind(address);
                channelGroup.add(future.channel());
                bindFutures.put(future, address);
            }
            return bindFutures;
        }
    });
    Map<ChannelFuture, SocketAddress> channelFutures = bindCallFuture.awaitUninterruptibly().getNow();
    if (!bindCallFuture.isSuccess()) {
        channelGroup.close().awaitUninterruptibly();
        throw new IOException(String.format("Failed to bind to addresses %s", addresses), bindCallFuture.cause());
    }
    final List<InternalInstrumented<SocketStats>> socketStats = new ArrayList<>();
    for (Map.Entry<ChannelFuture, SocketAddress> entry : channelFutures.entrySet()) {
        // We'd love to observe interruption, but if interrupted we will need to close the channel,
        // which itself would need an await() to guarantee the port is not used when the method
        // returns. See #6850
        final ChannelFuture future = entry.getKey();
        if (!future.awaitUninterruptibly().isSuccess()) {
            channelGroup.close().awaitUninterruptibly();
            throw new IOException(String.format("Failed to bind to address %s", entry.getValue()), future.cause());
        }
        final InternalInstrumented<SocketStats> listenSocketStats = new ListenSocket(future.channel());
        channelz.addListenSocket(listenSocketStats);
        socketStats.add(listenSocketStats);
        future.channel().closeFuture().addListener(new ChannelFutureListener() {

            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                channelz.removeListenSocket(listenSocketStats);
            }
        });
    }
    listenSocketStatsList = Collections.unmodifiableList(socketStats);
}

Example 10 with SocketStats

use of io.grpc.InternalChannelz.SocketStats in project grpc-java by grpc.

the class ChannelzService method getSocket.

/**
 * Returns a socket.
 */
@Override
public void getSocket(GetSocketRequest request, StreamObserver<GetSocketResponse> responseObserver) {
    InternalInstrumented<SocketStats> s = channelz.getSocket(request.getSocketId());
    if (s == null) {
        responseObserver.onError(Status.NOT_FOUND.withDescription("Can't find socket " + request.getSocketId()).asRuntimeException());
        return;
    }
    GetSocketResponse resp;
    try {
        resp = GetSocketResponse.newBuilder().setSocket(ChannelzProtoUtil.toSocket(s)).build();
    } catch (StatusRuntimeException e) {
        responseObserver.onError(e);
        return;
    }
    responseObserver.onNext(resp);
    responseObserver.onCompleted();
}