add hello_kitty.proto

Author: chenll

examples.iml

@@ -0,0 +1,73 @@
+package io.grpc.examples.hellokitty;
+
+import io.grpc.ManagedChannel;
+import io.grpc.ManagedChannelBuilder;
+import io.grpc.StatusRuntimeException;
+
+import java.util.concurrent.TimeUnit;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+public class HelloKittyClient {
+  private static final Logger logger = Logger.getLogger(HelloKittyClient.class.getName());
+
+  private final ManagedChannel channel;
+  private final HelloKittyGrpc.HelloKittyBlockingStub blockingStub;
+
+  /**
+   * Construct client connecting to HelloWorld server at {@code host:port}.
+   */
+  public HelloKittyClient(String host, int port) {
+    this(ManagedChannelBuilder.forAddress(host, port)
+        // Channels are secure by default (via SSL/TLS). For the example we disable TLS to avoid
+        // needing certificates.
+        .usePlaintext(true)
+        .build());
+  }
+
+  /**
+   * Construct client for accessing RouteGuide server using the existing channel.
+   */
+  HelloKittyClient(ManagedChannel channel) {
+    this.channel = channel;
+    blockingStub = HelloKittyGrpc.newBlockingStub(channel);
+  }
+
+  public void shutdown() throws InterruptedException {
+    channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
+  }
+
+  /**
+   * Say hello to server.
+   */
+  public void greet(String name) {
+    logger.info("Will try to greet " + name + " ...");
+    HelloKittyRequest request = HelloKittyRequest.newBuilder().setName(name).build();
+    HelloKittyReply response;
+    try {
+      response = blockingStub.sayHello(request);
+    } catch (StatusRuntimeException e) {
+      logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
+      return;
+    }
+    logger.info("Greeting: " + response.getMessage());
+  }
+
+  /**
+   * Greet server. If provided, the first element of {@code args} is the name to use in the
+   * greeting.
+   */
+  public static void main(String[] args) throws Exception {
+    HelloKittyClient client = new HelloKittyClient("localhost", 50052);
+    try {
+      /* Access a service running on the local machine on port 50051 */
+      String user = "kitty";
+      if (args.length > 0) {
+        user = args[0]; /* Use the arg as the name to greet if provided */
+      }
+      client.greet(user);
+    } finally {
+      client.shutdown();
+    }
+  }
+}

src/main/java/io/grpc/examples/hellokitty/HelloKittyClient.java

@@ -0,0 +1,70 @@
+package io.grpc.examples.hellokitty;
+
+import io.grpc.Server;
+import io.grpc.ServerBuilder;
+import io.grpc.examples.helloworld.HelloWorldServer;
+import io.grpc.stub.StreamObserver;
+
+import java.io.IOException;
+import java.util.logging.Logger;
+
+public class HelloKittyServer {
+
+
+  private static final Logger logger = Logger.getLogger(HelloWorldServer.class.getName());
+
+  private Server server;
+
+  private void start() throws IOException {
+    /* The port on which the server should run */
+    int port = 50052;
+    server = ServerBuilder.forPort(port)
+        .addService(new HelloKittyServerImpl())
+        .build()
+        .start();
+    logger.info("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");
+        HelloKittyServer.this.stop();
+        System.err.println("*** server shut down");
+      }
+    });
+  }
+
+  private void stop() {
+    if (server != null) {
+      server.shutdown();
+    }
+  }
+
+  /**
+   * 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 HelloKittyServer server = new HelloKittyServer();
+    server.start();
+    server.blockUntilShutdown();
+  }
+
+  static class HelloKittyServerImpl extends HelloKittyGrpc.HelloKittyImplBase {
+
+    @Override
+    public void sayHello(HelloKittyRequest req, StreamObserver<HelloKittyReply> responseObserver) {
+      HelloKittyReply reply = HelloKittyReply.newBuilder().setMessage("Hello " + req.getName()).build();
+      responseObserver.onNext(reply);
+      responseObserver.onCompleted();
+    }
+  }
+}

src/main/java/io/grpc/examples/hellokitty/HelloKittyServer.java

@@ -0,0 +1,40 @@
+// Copyright 2015, gRPC Authors
+// All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+syntax = "proto3";
+
+option java_multiple_files = true;
+option java_package = "io.grpc.examples.hellokitty";
+option java_outer_classname = "HelloKittyProto";
+option objc_class_prefix = "HLK";
+
+package hellokitty;
+
+// The greeting service definition.
+service HelloKitty {
+    // Sends a greeting
+    rpc SayHello (HelloKittyRequest) returns (HelloKittyReply) {
+    }
+}
+
+// The request message containing the user's name.
+message HelloKittyRequest {
+    string name = 1;
+}
+
+// The response message containing the greetings
+message HelloKittyReply {
+    string message = 1;
+    int32 code = 2;
+}