New Ice/callback demo (C++) (#293)

Author: bernardnormier

cpp/Ice/callback/AlarmClock.ice

@@ -0,0 +1,28 @@
+// Copyright (c) ZeroC, Inc.
+
+#pragma once
+
+module EarlyRiser
+{
+    /// Indicates the button pressed when the alarm rang.
+    enum ButtonPressed { Snooze, Stop }
+
+    /// Represents a simple alarm clock. It's the "callback" in this demo, and it's implemented by the client.
+    interface AlarmClock
+    {
+        /// Rings the alarm clock.
+        /// @param message The message to display.
+        /// @return The button pressed by the user.
+        ButtonPressed ring(string message);
+    }
+
+    /// Represents the wake up service provided by the server.
+    interface WakeUpService
+    {
+        /// Schedules a call to {@link AlarmClock::ring} at the specified time.
+        /// @param alarmClock A proxy to the alarm clock to ring.
+        /// @param timeStamp The time to ring the alarm clock. It's encoded as the number of ticks (100 nanoseconds)
+        /// since January 1, 0001 00:00:00 UTC in the Gregorian calendar.
+        void wakeMeUp(AlarmClock* alarmClock, long timeStamp);
+    }
+}

cpp/Ice/callback/CMakeLists.txt

@@ -4,10 +4,10 @@ project(callback CXX)
 
 include(../../cmake/common.cmake)
 
-add_executable(client Client.cpp Callback.ice)
+add_executable(client Client.cpp MockAlarmClock.h MockAlarmClock.cpp AlarmClock.ice)
 slice2cpp_generate(client)
 target_link_libraries(client Ice::Ice)
 
-add_executable(server Server.cpp CallbackSenderI.cpp CallbackSenderI.h Callback.ice)
+add_executable(server Server.cpp SimpleWakeUpService.h SimpleWakeUpService.cpp AlarmClock.ice)
 slice2cpp_generate(server)
 target_link_libraries(server Ice::Ice)

cpp/Ice/callback/Callback.ice

@@ -1,121 +1,57 @@
 // Copyright (c) ZeroC, Inc.
 
-#include "Callback.h"
-#include <Ice/Ice.h>
+#include "MockAlarmClock.h"
+
 #include <iostream>
 
+using namespace EarlyRiser;
 using namespace std;
-using namespace Demo;
-
-class CallbackReceiverI final : public CallbackReceiver
-{
-public:
-    void callback(const Ice::Current&) final { cout << "received callback" << endl; }
-};
 
-int run(const shared_ptr<Ice::Communicator>&);
-
-int
-main(int argc, char* argv[])
+namespace
 {
-    int status = 0;
-
-    try
+    // Converts a time point to a time stamp.
+    int64_t toTimeStamp(const chrono::system_clock::time_point& timePoint)
     {
-        //
-        // CommunicatorHolder's ctor initializes an Ice communicator,
-        // and its dtor destroys this communicator.
-        //
-        const Ice::CommunicatorHolder ich(argc, argv, "config.client");
+        const int daysBeforeEpoch = 719162;
 
-        //
-        // The communicator initialization removes all Ice-related arguments from argc/argv
-        //
-        if (argc > 1)
-        {
-            cerr << argv[0] << ": too many arguments" << endl;
-            status = 1;
-        }
-        else
-        {
-            status = run(ich.communicator());
-        }
-    }
-    catch (const std::exception& ex)
-    {
-        cerr << argv[0] << ": " << ex.what() << endl;
-        status = 1;
-    }
+        int64_t timeStampMicro =
+            chrono::duration_cast<chrono::microseconds>(timePoint.time_since_epoch() + daysBeforeEpoch * 24h).count();
 
-    return status;
+        // The time stamp is in ticks, where each tick is 100 nanoseconds = 0.1 microsecond.
+        return timeStampMicro * 10;
+    }
 }
 
-void menu();
-
 int
-run(const shared_ptr<Ice::Communicator>& communicator)
+main(int argc, char* argv[])
 {
-    auto sender = Ice::checkedCast<CallbackSenderPrx>(
-        communicator->propertyToProxy("CallbackSender.Proxy")->ice_twoway()->ice_secure(false));
-    if (!sender)
-    {
-        cerr << "invalid proxy" << endl;
-        return 1;
-    }
+    // Create an Ice communicator to initialize the Ice runtime.
+    const Ice::CommunicatorHolder communicatorHolder{argc, argv};
+    const Ice::CommunicatorPtr& communicator = communicatorHolder.communicator();
+
+    // Create an object adapter that listens for incoming requests and dispatches them to servants.
+    // Since we don't specify a port, the OS will choose an ephemeral port. This allows multiple client applications to
+    // run concurrently on the same host.
+    Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapterWithEndpoints("AlarmClockAdapter", "tcp");
 
-    auto adapter = communicator->createObjectAdapter("Callback.Client");
-    adapter->add(make_shared<CallbackReceiverI>(), Ice::stringToIdentity("callbackReceiver"));
+    // Register the MockAlarmClock servant with the adapter, and get an alarm clock proxy.
+    auto mockAlarmClock = make_shared<Client::MockAlarmClock>();
+    auto alarmClock = adapter->add<AlarmClockPrx>(mockAlarmClock, Ice::stringToIdentity("alarmClock"));
+
+    // Start dispatching requests.
     adapter->activate();
+    cout << "Listening on ephemeral port..." << endl;
 
-    auto receiver =
-        Ice::uncheckedCast<CallbackReceiverPrx>(adapter->createProxy(Ice::stringToIdentity("callbackReceiver")));
+    // Create a proxy to the wake-up service.
+    WakeUpServicePrx wakeUpService{communicator, "wakeUpService:tcp -h localhost -p 4061"};
 
-    menu();
+    // Schedule a wake-up call in 5 seconds.
+    wakeUpService->wakeMeUp(alarmClock, toTimeStamp(chrono::system_clock::now() + chrono::seconds{5}));
+    cout << "Wake-up call scheduled, falling asleep..." << endl;
 
-    char c = 'x';
-    do
-    {
-        try
-        {
-            cout << "==> ";
-            cin >> c;
-            if (c == 't')
-            {
-                sender->initiateCallback(receiver);
-            }
-            else if (c == 's')
-            {
-                sender->shutdown();
-            }
-            else if (c == 'x')
-            {
-                // Nothing to do
-            }
-            else if (c == '?')
-            {
-                menu();
-            }
-            else
-            {
-                cout << "unknown command `" << c << "'" << endl;
-                menu();
-            }
-        }
-        catch (const Ice::Exception& ex)
-        {
-            cerr << ex << endl;
-        }
-    } while (cin.good() && c != 'x');
+    // Wait until the "stop" button is pressed on the mock alarm clock.
+    mockAlarmClock->wait();
+    cout << "Stop button pressed, exiting..." << endl;
 
     return 0;
 }
-
-void
-menu()
-{
-    cout << "usage:\n"
-            "t: send callback\n"
-            "s: shutdown server\n"
-            "x: exit\n"
-            "?: help\n";
-}

cpp/Ice/callback/CallbackSenderI.cpp

@@ -0,0 +1,33 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "MockAlarmClock.h"
+
+#include <iostream>
+
+using namespace EarlyRiser;
+using namespace std;
+
+ButtonPressed
+Client::MockAlarmClock::ring(string message, const Ice::Current&)
+{
+    cout << "Dispatching ring request { message = '" << message << "' }" << endl;
+
+    if (_needMoreTime)
+    {
+        cout << "Returning " << ButtonPressed::Snooze << " to request more time." << endl;
+        _needMoreTime = false; // we only snooze one time
+        return ButtonPressed::Snooze;
+    }
+    else
+    {
+        _stopPromise.set_value();
+        cout << "Returning " << ButtonPressed::Stop << " to stop the alarm." << endl;
+        return ButtonPressed::Stop;
+    }
+}
+
+void
+Client::MockAlarmClock::wait()
+{
+    _stopPromise.get_future().wait();
+}

cpp/Ice/callback/CallbackSenderI.h

@@ -0,0 +1,28 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef MOCK_ALARM_CLOCK_H
+#define MOCK_ALARM_CLOCK_H
+
+#include "AlarmClock.h"
+
+#include <future>
+
+namespace Client
+{
+    /// MockAlarmClock is an Ice servant that implements Slice interface AlarmClock.
+    class MockAlarmClock : public EarlyRiser::AlarmClock
+    {
+    public:
+        // Implements the pure virtual function in the base class (AlarmClock) generated by the Slice compiler.
+        EarlyRiser::ButtonPressed ring(std::string message, const Ice::Current&) override;
+
+        /// Waits until ring returns ButtonPressed::Stop. Can only be called once.
+        void wait();
+
+    private:
+        bool _needMoreTime{true};
+        std::promise<void> _stopPromise;
+    };
+}
+
+#endif

cpp/Ice/callback/Client.cpp

@@ -1,10 +1,15 @@
 # Callback
 
-A simple callback demo that illustrates how a client can pass a proxy
-to a server, invoke an operation in the server, and the [server call
-back][1] into an object provided by the client as part of that invocation.
+The Callback demo illustrates how to implement callbacks in a client application.
 
-To run the demo, first start the server:
+In this demo, the client hosts an alarm clock (an Ice object), and asks the server's wake up service to call this
+object at a later time. The server opens a TCP connection to the client when making this call.
+
+```mermaid
+flowchart LR
+    c[Client<br>hosts AlarmClock] --connection1--> s[Server:4061<br>hosts WakeUpService]
+    s --connection2--> c
+```
 
 To build the demo run:
 
@@ -40,5 +45,3 @@ In a separate window, start the client:
 ```shell
 build\Release\client
 ```
-
-[1]: https://doc.zeroc.com/ice/3.7/client-server-features/the-ice-threading-model/nested-invocations