package me.sup2is;

import io.grpc.stub.StreamObserver;

public class GreeterImpl extends GreeterGrpc.GreeterImplBase {

    @Override
    public void hello(final Hello.Request request, final StreamObserver<Hello.Response> responseObserver) {

        final String str = "Hello " + request.getName() + "(" + request.getAge() + ")";
        System.out.println(str);

        final Hello.Response response = Hello.Response.newBuilder()
                .setStr(str)
                .build();

        responseObserver.onNext(response);
        responseObserver.onCompleted();

    }
}

package me.sup2is;

import java.io.IOException;
import java.util.concurrent.TimeUnit;

import io.grpc.Server;
import io.grpc.ServerBuilder;

public class GreeterServer {

    private Server server;

    private void start() throws IOException {
        /* The port on which the server should run */
        int port = 50051;
        server = ServerBuilder.forPort(port)
                .addService(new GreeterImpl())
                .build()
                .start();
        System.out.println("Server started, listening on " + port);
        Runtime.getRuntime().addShutdownHook(new Thread() {
            @Override
            public void run() {
                // Use stderr here since the logger may have been reset by its JVM shutdown hook.
                System.err.println("*** shutting down gRPC server since JVM is shutting down");
                try {
                    GreeterServer.this.stop();
                } catch (InterruptedException e) {
                    e.printStackTrace(System.err);
                }
                System.err.println("*** server shut down");
            }
        });
    }

    private void stop() throws InterruptedException {
        if (server != null) {
            server.shutdown().awaitTermination(30, TimeUnit.SECONDS);
        }
    }

    /**
     * Await termination on the main thread since the grpc library uses daemon threads.
     */
    private void blockUntilShutdown() throws InterruptedException {
        if (server != null) {
            server.awaitTermination();
        }
    }

    /**
     * Main launches the server from the command line.
     */
    public static void main(String[] args) throws IOException, InterruptedException {
        final GreeterServer server = new GreeterServer();
        server.start();
        server.blockUntilShutdown();
    }


}

package me.sup2is;

import io.grpc.Channel;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import io.grpc.StatusRuntimeException;

import java.util.concurrent.TimeUnit;

public class GreeterClient {

    private final GreeterGrpc.GreeterBlockingStub greeterBlockingStub;

    public GreeterClient(Channel channel) {
//         'channel' here is a Channel, not a ManagedChannel, so it is not this code's responsibility to
//         shut it down.

//         Passing Channels to code makes code easier to test and makes it easier to reuse Channels.
        greeterBlockingStub = GreeterGrpc.newBlockingStub(channel);
    }

    public static void main(String[] args) throws Exception {
        String user = "hyeon seop";
        int age = 28;

        // Access a service running on the local machine on port 50051
        String target = "localhost:50051";

        ManagedChannel channel = ManagedChannelBuilder.forTarget(target)
                .usePlaintext()
                .build();

        try {
            GreeterClient client = new GreeterClient(channel);
            client.greet(user, age);
        } finally {
            // ManagedChannels use resources like threads and TCP connections. To prevent leaking these
            // resources the channel should be shut down when it will no longer be used. If it may be used
            // again leave it running.
            channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
        }
    }

    public void greet(String name, int age) {
        System.out.println("Will try to greet " + name  + "(" + age + ")"+ " ...");

        final Hello.Request request = Hello.Request.newBuilder()
                .setAge(age)
                .setName(name)
                .build();

        Hello.Response response;

        try {
            response = greeterBlockingStub.hello(request);
        } catch (StatusRuntimeException e) {
            System.out.println("RPC failed:" +  e.getStatus());
            return;
        }
        System.out.println("Greeter Server: " + response.getStr());
    }

}