Rework filesystem demo in C++ (#275)

Author: bernardnormier

cpp/Manual/simpleFilesystem/CMakeLists.txt renamed to cpp/Ice/filesystem/CMakeLists.txt

@@ -1,13 +1,13 @@
 cmake_minimum_required(VERSION 3.16)
 
-project(manual_simpleFilesystem CXX)
+project(filesystem CXX)
 
 include(../../cmake/common.cmake)
 
 add_executable(client Client.cpp Filesystem.ice)
 slice2cpp_generate(client)
 target_link_libraries(client Ice::Ice)
 
-add_executable(server Server.cpp FilesystemI.cpp FilesystemI.h Filesystem.ice)
+add_executable(server Server.cpp Memory.cpp Memory.h Filesystem.ice)
 slice2cpp_generate(server)
 target_link_libraries(server Ice::Ice)

cpp/Ice/filesystem/Client.cpp

@@ -0,0 +1,57 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "Filesystem.h"
+
+#include <Ice/Ice.h>
+#include <iostream>
+
+using namespace std;
+using namespace Filesystem;
+
+/// Recursively print the contents of a directory in tree fashion. For files, show the contents of each file.
+/// @param dir The directory to list.
+/// @param depth The current nesting level (for indentation).
+static void
+listRecursive(const DirectoryPrx& dir, size_t depth = 0)
+{
+    const string indent(++depth, '\t');
+
+    // The node proxies returned by list() are never null.
+    NodeSeq contents = dir->list();
+
+    for (const optional<NodePrx>& node : contents)
+    {
+        auto subdir = Ice::checkedCast<DirectoryPrx>(node);
+        cout << indent << node->name() << (subdir ? " (directory):" : " (file):") << endl;
+        if (subdir)
+        {
+            listRecursive(*subdir, depth);
+        }
+        else
+        {
+            auto file = Ice::uncheckedCast<FilePrx>(node);
+            Lines lines = file->read();
+            for (const auto& line : lines)
+            {
+                cout << indent << '\t' << line << endl;
+            }
+        }
+    }
+}
+
+int
+main(int argc, char* argv[])
+{
+    // Create an Ice communicator to initialize the Ice runtime.
+    const Ice::CommunicatorHolder communicatorHolder{argc, argv};
+    const Ice::CommunicatorPtr& communicator = communicatorHolder.communicator();
+
+    // Create a proxy for the root directory.
+    DirectoryPrx rootDir{communicator, "RootDir:tcp -h localhost -p 4061"};
+
+    // Recursively list the contents of the root directory.
+    cout << "Contents of root directory:" << endl;
+    listRecursive(rootDir);
+
+    return 0;
+}

cpp/Ice/filesystem/Filesystem.ice

@@ -0,0 +1,48 @@
+// Copyright (c) ZeroC, Inc.
+
+#pragma once
+
+module Filesystem
+{
+    /// Represents a write failure.
+    exception WriteException
+    {
+        /// The reason for the write failure.
+        string reason;
+    }
+
+    /// The base interface for files and directories.
+    interface Node
+    {
+        /// Gets the name of this node.
+        /// @return The name of the node.
+        idempotent string name();
+    }
+
+    /// The contents of a file.
+    sequence<string> Lines;
+
+    /// Represents a file in our filesystem. A file holds lines of text.
+    interface File extends Node
+    {
+        /// Reads the file and returns its contents.
+        /// @return The contents of the file.
+        idempotent Lines read();
+
+        /// Overwrites the file with new contents.
+        /// @param text The new contents of the file.
+        /// @throws WriteException Thrown if the file cannot be written to.
+        idempotent void write(Lines text) throws WriteException;
+    }
+
+    /// A list of node proxies.
+    sequence<Node*> NodeSeq;
+
+    /// Represents a directory. A directory holds files and other directories.
+    interface Directory extends Node
+    {
+        /// Gets the contents of the directory.
+        /// @return The contents of the directory, as a list of non-null node proxies.
+        idempotent NodeSeq list();
+    }
+}

cpp/Ice/filesystem/Memory.cpp

@@ -0,0 +1,56 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "Memory.h"
+
+using namespace std;
+using namespace Memory;
+
+//
+// MNode
+//
+
+MNode::MNode(string name) : _name(std::move(name)) {}
+
+string
+MNode::name(const Ice::Current&)
+{
+    return _name;
+}
+
+//
+// MFile
+//
+
+Filesystem::Lines
+MFile::read(const Ice::Current&)
+{
+    return _lines;
+}
+
+void
+MFile::write(Filesystem::Lines text, const Ice::Current&)
+{
+    writeDirect(std::move(text));
+}
+
+void
+MFile::writeDirect(Filesystem::Lines text)
+{
+    _lines = std::move(text);
+}
+
+//
+// MDirectory
+//
+
+Filesystem::NodeSeq
+MDirectory::list(const Ice::Current&)
+{
+    return _contents;
+}
+
+void
+MDirectory::addChild(Filesystem::NodePrx child)
+{
+    _contents.push_back(std::move(child));
+}

cpp/Ice/filesystem/Memory.h

@@ -0,0 +1,62 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef MEMORY_H
+#define MEMORY_H
+
+#include "Filesystem.h"
+
+// Provides an in-memory implementation of the Filesystem objects.
+namespace Memory
+{
+    /// Implements Slice interface Node.
+    class MNode : public virtual Filesystem::Node
+    {
+    public:
+        /// Constructs a new MNode servant
+        explicit MNode(std::string name);
+
+        // Implements Slice operation name.
+        std::string name(const Ice::Current& current) override;
+
+    private:
+        std::string _name;
+    };
+
+    /// Implements Slice interface File.
+    class MFile final : public Filesystem::File, public MNode
+    {
+    public:
+        using MNode::MNode;
+
+        // Implements Slice operation read.
+        Filesystem::Lines read(const Ice::Current&) final;
+
+        // Implements Slice operation write.
+        void write(Filesystem::Lines text, const Ice::Current&) final;
+
+        // Write directly to this file, without going through an Ice operation.
+        void writeDirect(Filesystem::Lines text);
+
+    private:
+        Filesystem::Lines _lines;
+    };
+
+    /// Implements Slice interface Directory.
+    class MDirectory final : public Filesystem::Directory, public MNode
+    {
+    public:
+        using MNode::MNode;
+
+        // Implements Slice operation list.
+        Filesystem::NodeSeq list(const Ice::Current&) final;
+
+        /// Adds a node to this directory.
+        /// @param child The node proxy to add.
+        void addChild(Filesystem::NodePrx child);
+
+    private:
+        Filesystem::NodeSeq _contents;
+    };
+}
+
+#endif

cpp/Manual/simpleFilesystem/README.md renamed to cpp/Ice/filesystem/README.md

@@ -1,7 +1,7 @@
-# Manual Simple Filesystem
+# Filesystem
 
-This demo implements the simple filesystem application shown at the
-end of the client and server C++ mapping chapters.
+This demo implements the filesystem application shown at the end of the client and server
+C++ mapping chapters.
 
 To build the demo run:
 

cpp/Ice/filesystem/Server.cpp

@@ -0,0 +1,61 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "Memory.h"
+
+#include <Ice/Ice.h>
+#include <iostream>
+
+using namespace std;
+using namespace Memory;
+
+int
+main(int argc, char* argv[])
+{
+    // CtrlCHandler is a helper class that handles Ctrl+C and similar signals. It must be constructed at the beginning
+    // of the program, before creating an Ice communicator or starting any thread.
+    Ice::CtrlCHandler ctrlCHandler;
+
+    // Create an Ice communicator to initialize the Ice runtime. The CommunicatorHolder is a RAII helper that creates
+    // the communicator in its constructor and destroys it when it goes out of scope.
+    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.
+    auto adapter = communicator->createObjectAdapterWithEndpoints("Filesystem", "tcp -p 4061");
+
+    // Create the root directory servant (with name "/" and no parent), and add this servant to the adapter.
+    auto root = make_shared<MDirectory>("/");
+    adapter->add(root, Ice::stringToIdentity("RootDir"));
+
+    // Create a file called "README", add this servant to the adapter, and add the corresponding proxy to the root
+    // directory.
+    auto file = make_shared<MFile>("README");
+    file->writeDirect({"This file system contains a collection of poetry."});
+    root->addChild(adapter->addWithUUID<Filesystem::FilePrx>(file));
+
+    // Create a directory called "Coleridge", add this servant to the adapter, and add the corresponding proxy to the
+    // root directory.
+    auto coleridge = make_shared<MDirectory>("Coleridge");
+    root->addChild(adapter->addWithUUID<Filesystem::DirectoryPrx>(coleridge));
+
+    // Create a file called "Kubla_Khan", add this servant to the adapter, and add the corresponding proxy to the
+    // Coleridge directory.
+    file = make_shared<MFile>("Kubla_Khan");
+    file->writeDirect(
+        {"In Xanadu did Kubla Khan",
+         "A stately pleasure-dome decree:",
+         "Where Alph, the sacred river, ran",
+         "Through caverns measureless to man",
+         "Down to a sunless sea."});
+    coleridge->addChild(adapter->addWithUUID<Filesystem::FilePrx>(file));
+
+    // Start dispatching requests after registering all servants.
+    adapter->activate();
+    cout << "Listening on port 4061..." << endl;
+
+    // Wait until the user presses Ctrl+C.
+    int signal = ctrlCHandler.wait();
+    cout << "Caught signal " << signal << ", exiting..." << endl;
+
+    return 0;
+}