first commit

.gitignore

@@ -0,0 +1,2 @@
+build/
+

CMakeLists.txt

@@ -0,0 +1,54 @@
+cmake_minimum_required(VERSION 3.16)
+project(DRDcmtkServer C CXX)
+
+include("common.cmake")
+
+get_filename_component(dcmtk_proto "rpc_idl/dr_dcmtk_idl.proto" ABSOLUTE)
+get_filename_component(dcmtk_proto_path "${dcmtk_proto}" PATH)
+
+set(dcmtk_proto_srcs "${CMAKE_CURRENT_BINARY_DIR}/dr_dcmtk_idl.pb.cc")
+set(dcmtk_proto_hdrs "${CMAKE_CURRENT_BINARY_DIR}/dr_dcmtk_idl.pb.h")
+set(dcmtk_grpc_srcs "${CMAKE_CURRENT_BINARY_DIR}/dr_dcmtk_idl.grpc.pb.cc")
+set(dcmtk_grpc_hdrs "${CMAKE_CURRENT_BINARY_DIR}/dr_dcmtk_idl.grpc.pb.h")
+
+add_custom_command(
+      OUTPUT "${dcmtk_proto_srcs}" "${dcmtk_proto_hdrs}" "${dcmtk_grpc_srcs}" "${dcmtk_grpc_hdrs}"
+      COMMAND ${_PROTOBUF_PROTOC}
+      ARGS --grpc_out "${CMAKE_CURRENT_BINARY_DIR}"
+        --cpp_out "${CMAKE_CURRENT_BINARY_DIR}"
+        -I "${dcmtk_proto_path}"
+        --plugin=protoc-gen-grpc="${_GRPC_CPP_PLUGIN_EXECUTABLE}"
+        "${dcmtk_proto}"
+      DEPENDS "${dcmtk_proto}")
+
+find_package(DCMTK REQUIRED)
+
+include_directories(
+  "${CMAKE_CURRENT_SOURCE_DIR}/serivce"
+	"${CMAKE_CURRENT_BINARY_DIR}"
+	"${DCMTK_INCLUDE_DIRS}"
+)
+
+add_library(dcmtk_grpc_proto
+  ${dcmtk_grpc_srcs}
+  ${dcmtk_grpc_hdrs}
+  ${dcmtk_proto_srcs}
+  ${dcmtk_proto_hdrs})
+target_link_libraries(dcmtk_grpc_proto
+  absl::check
+  ${_REFLECTION}
+  ${_GRPC_GRPCPP}
+  ${_PROTOBUF_LIBPROTOBUF})
+
+add_executable(dcmtk-server "main.cc" "service/pb_basic.cc" "service/pb_dcm.cc")
+target_link_libraries(dcmtk-server
+  dcmtk_grpc_proto
+  absl::check
+  absl::flags
+  absl::flags_parse
+  absl::log
+  absl::log_initialize
+  ${_REFLECTION}
+  ${_GRPC_GRPCPP}
+  ${_PROTOBUF_LIBPROTOBUF}
+  ${DCMTK_LIBRARIES})

common.cmake

@@ -0,0 +1,125 @@
+# Copyright 2018 gRPC authors.
+#
+# 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.
+#
+# cmake build file for C++ route_guide example.
+# Assumes protobuf and gRPC have been installed using cmake.
+# See cmake_externalproject/CMakeLists.txt for all-in-one cmake build
+# that automatically builds all the dependencies before building route_guide.
+
+cmake_minimum_required(VERSION 3.16)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED True)
+
+if(MSVC)
+  add_definitions(-D_WIN32_WINNT=0x600)
+endif()
+
+find_package(Threads REQUIRED)
+
+if(GRPC_AS_SUBMODULE)
+  # One way to build a projects that uses gRPC is to just include the
+  # entire gRPC project tree via "add_subdirectory".
+  # This approach is very simple to use, but the are some potential
+  # disadvantages:
+  # * it includes gRPC's CMakeLists.txt directly into your build script
+  #   without and that can make gRPC's internal setting interfere with your
+  #   own build.
+  # * depending on what's installed on your system, the contents of submodules
+  #   in gRPC's third_party/* might need to be available (and there might be
+  #   additional prerequisites required to build them). Consider using
+  #   the gRPC_*_PROVIDER options to fine-tune the expected behavior.
+  #
+  # A more robust approach to add dependency on gRPC is using
+  # cmake's ExternalProject_Add (see cmake_externalproject/CMakeLists.txt).
+
+  # Include the gRPC's cmake build (normally grpc source code would live
+  # in a git submodule called "third_party/grpc", but this example lives in
+  # the same repository as gRPC sources, so we just look a few directories up)
+  add_subdirectory(../../.. ${CMAKE_CURRENT_BINARY_DIR}/grpc EXCLUDE_FROM_ALL)
+  message(STATUS "Using gRPC via add_subdirectory.")
+
+  # After using add_subdirectory, we can now use the grpc targets directly from
+  # this build.
+  set(_PROTOBUF_LIBPROTOBUF libprotobuf)
+  set(_REFLECTION grpc++_reflection)
+  set(_ORCA_SERVICE grpcpp_orca_service)
+  if(CMAKE_CROSSCOMPILING)
+    find_program(_PROTOBUF_PROTOC protoc)
+  else()
+    set(_PROTOBUF_PROTOC $<TARGET_FILE:protobuf::protoc>)
+  endif()
+  set(_GRPC_GRPCPP grpc++)
+  if(CMAKE_CROSSCOMPILING)
+    find_program(_GRPC_CPP_PLUGIN_EXECUTABLE grpc_cpp_plugin)
+  else()
+    set(_GRPC_CPP_PLUGIN_EXECUTABLE $<TARGET_FILE:grpc_cpp_plugin>)
+  endif()
+elseif(GRPC_FETCHCONTENT)
+  # Another way is to use CMake's FetchContent module to clone gRPC at
+  # configure time. This makes gRPC's source code available to your project,
+  # similar to a git submodule.
+  message(STATUS "Using gRPC via add_subdirectory (FetchContent).")
+  include(FetchContent)
+  FetchContent_Declare(
+    grpc
+    GIT_REPOSITORY https://github.com/grpc/grpc.git
+    # when using gRPC, you will actually set this to an existing tag, such as
+    # v1.25.0, v1.26.0 etc..
+    # For the purpose of testing, we override the tag used to the commit
+    # that's currently under test.
+    GIT_TAG        vGRPC_TAG_VERSION_OF_YOUR_CHOICE)
+  FetchContent_MakeAvailable(grpc)
+
+  # Since FetchContent uses add_subdirectory under the hood, we can use
+  # the grpc targets directly from this build.
+  set(_PROTOBUF_LIBPROTOBUF libprotobuf)
+  set(_REFLECTION grpc++_reflection)
+  set(_PROTOBUF_PROTOC $<TARGET_FILE:protoc>)
+  set(_GRPC_GRPCPP grpc++)
+  if(CMAKE_CROSSCOMPILING)
+    find_program(_GRPC_CPP_PLUGIN_EXECUTABLE grpc_cpp_plugin)
+  else()
+    set(_GRPC_CPP_PLUGIN_EXECUTABLE $<TARGET_FILE:grpc_cpp_plugin>)
+  endif()
+else()
+  # This branch assumes that gRPC and all its dependencies are already installed
+  # on this system, so they can be located by find_package().
+
+  # Find Protobuf installation
+  # Looks for protobuf-config.cmake file installed by Protobuf's cmake installation.
+  option(protobuf_MODULE_COMPATIBLE TRUE)
+  find_package(Protobuf CONFIG REQUIRED)
+  message(STATUS "Using protobuf ${Protobuf_VERSION}")
+
+  set(_PROTOBUF_LIBPROTOBUF protobuf::libprotobuf)
+  set(_REFLECTION gRPC::grpc++_reflection)
+  if(CMAKE_CROSSCOMPILING)
+    find_program(_PROTOBUF_PROTOC protoc)
+  else()
+    set(_PROTOBUF_PROTOC $<TARGET_FILE:protobuf::protoc>)
+  endif()
+
+  # Find gRPC installation
+  # Looks for gRPCConfig.cmake file installed by gRPC's cmake installation.
+  find_package(gRPC CONFIG REQUIRED)
+  message(STATUS "Using gRPC ${gRPC_VERSION}")
+
+  set(_GRPC_GRPCPP gRPC::grpc++)
+  if(CMAKE_CROSSCOMPILING)
+    find_program(_GRPC_CPP_PLUGIN_EXECUTABLE grpc_cpp_plugin)
+  else()
+    set(_GRPC_CPP_PLUGIN_EXECUTABLE $<TARGET_FILE:gRPC::grpc_cpp_plugin>)
+  endif()
+endif()

main.cc

@@ -0,0 +1,31 @@
+#include <grpcpp/grpcpp.h>
+#include <grpcpp/health_check_service_interface.h>
+#include <grpcpp/ext/proto_server_reflection_plugin.h>
+
+#include "dr_dcmtk_idl.grpc.pb.h"
+
+#include "service/pb_basic.h"
+#include "service/pb_dcm.h"
+
+void RunServer() {
+  std::string server_address("0.0.0.0:6199");
+  BasicServiceImpl basicService;
+  DcmServiceImpl   dcmService;
+
+  grpc::EnableDefaultHealthCheckService(true);
+  grpc::reflection::InitProtoReflectionServerBuilderPlugin();
+  ServerBuilder builder;
+  builder.AddListeningPort(server_address, grpc::InsecureServerCredentials());
+  builder.RegisterService(&basicService);
+  builder.RegisterService(&dcmService);
+
+  std::unique_ptr<Server> server(builder.BuildAndStart());
+  std::cout << "Server listening on " << server_address << std::endl;
+
+  server->Wait();
+}
+
+int main(int argc, char** argv) {
+  RunServer();
+  return 0;
+}

rpc_idl/dr_dcmtk_idl.proto

@@ -0,0 +1,31 @@
+syntax = "proto3";
+
+option go_package = "dr_dcmtk_pb/";
+
+package dr.dcmtk;
+
+message EmptyRequest {}
+
+service Basic {
+  rpc SoftwareInfo (EmptyRequest) returns (SoftwareInfoReply) {}
+}
+
+message SoftwareInfoReply {
+  string module     = 1;
+  string desc       = 2;
+  string build      = 3;
+  string version    = 4;
+}
+
+service Dcm {
+  rpc GenerateUniqueIdentifier(UidRootRequest) returns (UidReply) {}
+}
+
+message UidRootRequest {
+  string uid_root = 1;
+  int32  number   = 2;
+}
+
+message UidReply {
+  repeated string instance_uid = 1;
+}

service/pb_basic.cc

@@ -0,0 +1,19 @@
+#include "pb_basic.h"
+
+using grpc::Server;
+using grpc::ServerBuilder;
+using grpc::ServerContext;
+using grpc::Status;
+using dr::dcmtk::EmptyRequest;
+using dr::dcmtk::SoftwareInfoReply;
+using dr::dcmtk::Basic;
+
+Status BasicServiceImpl::SoftwareInfo(ServerContext* context, const EmptyRequest* request, SoftwareInfoReply* response) {
+  std::string prefix("Hello ");
+  response->set_module("dcmtk-server");
+  response->set_desc("dr dcmtk server");
+  response->set_build("2005-05-28 16:27:00");
+  response->set_version("0.0.0");
+  char uid[100];
+  return Status::OK;
+}

service/pb_basic.h

@@ -0,0 +1,22 @@
+#include <iostream>
+#include <memory>
+#include <string>
+
+#include <dcmtk/config/osconfig.h> 
+#include <dcmtk/dcmdata/dcuid.h>
+#include <dcmtk/ofstd/ofstream.h> 
+#include <grpcpp/grpcpp.h>
+
+#include "dr_dcmtk_idl.grpc.pb.h"
+
+using grpc::Server;
+using grpc::ServerBuilder;
+using grpc::ServerContext;
+using grpc::Status;
+using dr::dcmtk::EmptyRequest;
+using dr::dcmtk::SoftwareInfoReply;
+using dr::dcmtk::Basic;
+
+class BasicServiceImpl final : public Basic::Service {
+  Status SoftwareInfo(ServerContext* context, const EmptyRequest* request, SoftwareInfoReply* response) override;
+};

service/pb_dcm.cc

@@ -0,0 +1,10 @@
+#include "pb_dcm.h"
+
+Status DcmServiceImpl::GenerateUniqueIdentifier(ServerContext* context, const UidRootRequest* request, UidReply* response) {
+  char uid[100];
+  auto uidRoot = request->uid_root();
+  for (auto i = 0; i < request->number(); i++) {
+    response->add_instance_uid(dcmGenerateUniqueIdentifier(uid, uidRoot.c_str()));
+  }
+  return Status::OK;
+}

service/pb_dcm.h

@@ -0,0 +1,22 @@
+#include <iostream>
+#include <memory>
+#include <string>
+
+#include <dcmtk/config/osconfig.h> 
+#include <dcmtk/dcmdata/dcuid.h>
+#include <dcmtk/ofstd/ofstream.h> 
+#include <grpcpp/grpcpp.h>
+
+#include "dr_dcmtk_idl.grpc.pb.h"
+
+using grpc::Server;
+using grpc::ServerBuilder;
+using grpc::ServerContext;
+using grpc::Status;
+using dr::dcmtk::UidRootRequest;
+using dr::dcmtk::UidReply;
+using dr::dcmtk::Dcm;
+
+class DcmServiceImpl final : public Dcm::Service {
+  Status GenerateUniqueIdentifier(ServerContext* context, const UidRootRequest* request, UidReply* response) override;
+};