Add IceBox CMake files

cpp/IceBox/hello/CMakeLists.txt

@@ -0,0 +1,13 @@
+cmake_minimum_required(VERSION 3.16)
+
+project(icebox_hello CXX)
+
+include(../../cmake/common.cmake)
+
+add_executable(client Client.cpp Hello.ice)
+slice2cpp_generate(client)
+target_link_libraries(client Ice::Ice)
+
+add_library(HelloService SHARED HelloI.cpp HelloI.h HelloServiceI.cpp HelloServiceI.h Hello.ice)
+slice2cpp_generate(HelloService)
+target_link_libraries(HelloService Ice::Ice Ice::IceBox)

cpp/IceBox/hello/Client.cpp

@@ -24,7 +24,7 @@ main(int argc, char* argv[])
         // CommunicatorHolder's ctor initializes an Ice communicator,
         // and its dtor destroys this communicator.
         //
-        const Ice::CommunicatorHolder ich(argc, argv, "config.client");
+        const Ice::CommunicatorHolder ich{argc, argv};
 
         //
         // The communicator initialization removes all Ice-related arguments from argc/argv
@@ -53,20 +53,13 @@ void menu();
 int
 run(const shared_ptr<Ice::Communicator>& communicator)
 {
-    auto twoway =
-        Ice::checkedCast<HelloPrx>(communicator->propertyToProxy("Hello.Proxy")->ice_twoway()->ice_secure(false));
-    if (!twoway)
-    {
-        cerr << "invalid proxy" << endl;
-        return 1;
-    }
+    HelloPrx twoway{communicator, "hello:tcp -h localhost -p 10000:udp -h localhost -p 10000"};
+
     auto oneway = twoway->ice_oneway();
     auto batchOneway = twoway->ice_batchOneway();
     auto datagram = twoway->ice_datagram();
     auto batchDatagram = twoway->ice_batchDatagram();
 
-    bool secure = false;
-
     menu();
 
     char c = 'x';
@@ -90,52 +83,16 @@ run(const shared_ptr<Ice::Communicator>& communicator)
             }
             else if (c == 'd')
             {
-                if (secure)
-                {
-                    cout << "secure datagrams are not supported" << endl;
-                }
-                else
-                {
-                    datagram->sayHello();
-                }
+                datagram->sayHello();
             }
             else if (c == 'D')
             {
-                if (secure)
-                {
-                    cout << "secure datagrams are not supported" << endl;
-                }
-                else
-                {
-                    batchDatagram->sayHello();
-                }
+                batchDatagram->sayHello();
             }
             else if (c == 'f')
             {
                 batchOneway->ice_flushBatchRequests();
-                if (!secure)
-                {
-                    batchDatagram->ice_flushBatchRequests();
-                }
-            }
-            else if (c == 'S')
-            {
-                secure = !secure;
-
-                twoway = twoway->ice_secure(secure);
-                oneway = oneway->ice_secure(secure);
-                batchOneway = batchOneway->ice_secure(secure);
-                datagram = datagram->ice_secure(secure);
-                batchDatagram = batchDatagram->ice_secure(secure);
-
-                if (secure)
-                {
-                    cout << "secure mode is now on" << endl;
-                }
-                else
-                {
-                    cout << "secure mode is now off" << endl;
-                }
+                batchDatagram->ice_flushBatchRequests();
             }
             else if (c == 'x')
             {
@@ -170,7 +127,6 @@ menu()
             "d: send greeting as datagram\n"
             "D: send greeting as batch datagram\n"
             "f: flush all batch requests\n"
-            "S: switch secure mode on/off\n"
             "x: exit\n"
             "?: help\n";
 }

cpp/IceBox/hello/HelloServiceI.cpp

@@ -1,29 +1,29 @@
 // Copyright (c) ZeroC, Inc.
 
-#include <HelloI.h>
-#include <HelloServiceI.h>
+#include "HelloServiceI.h"
+#include "HelloI.h"
+
 #include <Ice/Ice.h>
 
+#include <iostream>
+
 using namespace std;
 
 extern "C"
 {
     //
     // Factory function
     //
-    ICE_DECLSPEC_EXPORT IceBox::Service* create(const shared_ptr<Ice::Communicator>&) { return new HelloServiceI; }
+    ICE_DECLSPEC_EXPORT IceBox::Service* create(const Ice::CommunicatorPtr&) { return new HelloServiceI; }
 }
 
 void
-HelloServiceI::start(
-    const string& name,
-    const shared_ptr<Ice::Communicator>& communicator,
-    const Ice::StringSeq& /*args*/)
+HelloServiceI::start(const string& name, const Ice::CommunicatorPtr& communicator, const Ice::StringSeq&)
 {
-    _adapter = communicator->createObjectAdapter(name);
-    auto hello = make_shared<HelloI>();
-    _adapter->add(hello, Ice::stringToIdentity("hello"));
+    _adapter = communicator->createObjectAdapterWithEndpoints("Hello", "tcp -p 10000:udp -p 10000");
+    _adapter->add(make_shared<HelloI>(), Ice::stringToIdentity("hello"));
     _adapter->activate();
+    cout << "Listening on port 10000..." << endl;
 }
 
 void

cpp/IceBox/hello/README.md

@@ -1,23 +1,48 @@
-  This demo shows how to create an [IceBox][1] service.
+# IceBox Hello
 
-To run this demo, open two terminal windows. In the first window,
-start the IceBox server:
+This demo shows how to create an [IceBox][1] service.
+
+```shell
+cmake -B build
+cmake --build build --config Release
 ```
-icebox --Ice.Config=config.icebox
+
+To run this demo, open two terminal windows. In the first window:
+
+**Linux:**
+
+```shell
+LD_LIBRARY_PATH=./build icebox --IceBox.Service.Hello="HelloService:create --Ice.Trace.Dispatch"
 ```
 
-In the second window, run the client:
+**macOS:**
+
+```shell
+DYLD_LIBRARY_PATH=./build icebox --IceBox.Service.Hello="HelloService:create --Ice.Trace.Dispatch"
 ```
-client
+
+**Windows:**
+
+```shell
+set PATH=%PATH%;./build/Release
+icebox --IceBox.Service.Hello="HelloService:create --Ice.Trace.Dispatch"
 ```
 
-To shut down IceBox, use `iceboxadmin`:
+In the second window, run the client:
+
+**Linux/macOS:**
+
+```shell
+./build/client
 ```
-iceboxadmin --Ice.Config=config.admin shutdown
+
+**Windows:**
+
+```shell
+build\Release\client
 ```
 
-Linux 32-bit
-------------
+## Linux 32-bit
 
 If you are using 32-bit binaries on a Linux 64-bit host, use
 `icebox32` instead of `icebox` to start the IceBox server.

cpp/cmake/common.cmake

@@ -7,4 +7,4 @@ find_package(Threads REQUIRED)
 
 set(Ice_DIR ${CMAKE_CURRENT_LIST_DIR} CACHE PATH "Path to Ice CMake configuration file")
 
-find_package(Ice REQUIRED CONFIG COMPONENTS DataStorm Glacier2 IceStorm)
+find_package(Ice REQUIRED CONFIG COMPONENTS DataStorm Glacier2 IceBox IceStorm)