feat: Add client interface.

CMakeLists.txt

@@ -12,6 +12,10 @@ project(
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
+# AppleClang complains about file has no symbol and abort the build.
+set(CMAKE_CXX_ARCHIVE_CREATE "<CMAKE_AR> Scr <TARGET> <LINK_FLAGS> <OBJECTS>")
+set(CMAKE_CXX_ARCHIVE_FINISH "<CMAKE_RANLIB> -no_warning_for_no_symbols -c <TARGET>")
+
 # Enable exporting compile commands
 set(CMAKE_EXPORT_COMPILE_COMMANDS
     ON

src/spider/CMakeLists.txt

@@ -1,15 +1,16 @@
 # set variable as CACHE INTERNAL to access it from other scope
-set(SPIDER_CORE_SOURCES
+set(SPIDER_CORE_SOURCES storage/MysqlStorage.cpp CACHE INTERNAL "spider core source files")
+
+set(SPIDER_CORE_HEADERS
     core/Error.hpp
     core/Data.hpp
     core/Task.hpp
     core/TaskGraph.hpp
     storage/MetadataStorage.hpp
     storage/DataStorage.hpp
-    storage/MysqlStorage.cpp
     storage/MysqlStorage.hpp
     CACHE INTERNAL
-    "spider core source files"
+    "spider core header files"
 )
 
 if(SPIDER_USE_STATIC_LIBS)
@@ -18,11 +19,57 @@ else()
     add_library(spider_core SHARED)
 endif()
 target_sources(spider_core PRIVATE ${SPIDER_CORE_SOURCES})
+target_sources(spider_core PUBLIC ${SPIDER_CORE_HEADERS})
 target_link_libraries(spider_core PUBLIC Boost::boost PRIVATE absl::flat_hash_map)
 
+set(SPIDER_CLIENT_SHARED_SOURCES
+    client/Data.cpp
+    client/Task.cpp
+    CACHE INTERNAL
+    "spider client shared source files"
+)
+
+set(SPIDER_CLIENT_SHARED_HEADERS
+    client/Data.hpp
+    client/Task.hpp
+    CACHE INTERNAL
+    "spider client shared header files"
+)
+
+add_library(spider_client_lib)
+target_sources(spider_client_lib PRIVATE ${SPIDER_CLIENT_SHARED_SOURCES})
+target_sources(spider_client_lib PUBLIC ${SPIDER_CLIENT_SHARED_HEADERS})
+
+set(SPIDER_CLIENT_SOURCES
+    client/TaskGraph.cpp
+    client/Future.cpp
+    CACHE INTERNAL
+    "spider client source files"
+)
+
+set(SPIDER_CLIENT_HEADERS
+    client/Spider.hpp
+    client/TaskGraph.hpp
+    client/Future.hpp
+    CACHE INTERNAL
+    "spider client header files"
+)
+
+add_library(spider_client)
+target_sources(spider_client PRIVATE ${SPIDER_CLIENT_SOURCES})
+target_sources(spider_client PUBLIC ${SPIDER_CLIENT_HEADERS})
+target_link_libraries(spider_client PRIVATE spider_core)
+target_link_libraries(spider_client PUBLIC spider_client_lib)
+add_library(spider::spider ALIAS spider_client)
+
 set(SPIDER_WORKER_SOURCES worker/worker.cpp CACHE INTERNAL "spider worker source files")
 
 add_executable(spider_worker)
 target_sources(spider_worker PRIVATE ${SPIDER_WORKER_SOURCES})
-target_link_libraries(spider_worker PRIVATE spider_core)
+target_link_libraries(
+    spider_worker
+    PRIVATE
+        spider_core
+        spider_client_lib
+)
 add_executable(spider::worker ALIAS spider_worker)

src/spider/client/Data.cpp

@@ -0,0 +1,40 @@
+#include "Data.hpp"
+
+#include <functional>
+#include <string>
+#include <vector>
+
+namespace spider {
+
+class DataImpl {};
+
+template <class T>
+auto Data<T>::get() -> T {
+    return T();
+}
+
+template <class T>
+void Data<T>::set_locality(std::vector<std::string> const& /*nodes*/, bool /*hard*/) {}
+
+template <class T>
+auto Data<T>::Builder::key(std::string const& /*key*/) -> Data<T>::Builder& {
+    return this;
+}
+
+template <class T>
+auto Data<T>::Builder::locality(std::vector<std::string> const& /*nodes*/, bool /*hard*/)
+        -> Data<T>::Builder& {
+    return this;
+}
+
+template <class T>
+auto Data<T>::Builder::cleanup(std::function<T const&()> const& /*f*/) -> Data<T>::Builder& {
+    return this;
+}
+
+template <class T>
+auto Data<T>::Builder::build(T const& /*t*/) -> Data<T> {
+    return Data<T>();
+}
+
+}  // namespace spider

src/spider/client/Data.hpp

@@ -0,0 +1,81 @@
+#ifndef SPIDER_CLIENT_DATA_HPP
+#define SPIDER_CLIENT_DATA_HPP
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace spider {
+
+class DataImpl;
+
+template <class T>
+class Data {
+private:
+    std::unique_ptr<DataImpl> m_impl;
+
+public:
+    /**
+     * Gets the values stored in Data.
+     * @return value stored in Data.
+     */
+    auto get() -> T;
+    /**
+     * Indicates that the data is persisted and should not be rollbacked
+     * on failure recovery.
+     */
+    // Not implemented in milestone 1
+    // void mark_persist();
+    /**
+     * Sets locality list of the data.
+     * @param nodes nodes that has locality
+     * @param hard true if the locality list is a hard requirement, false otherwise
+     */
+    void set_locality(std::vector<std::string> const& nodes, bool hard);
+
+    class Builder {
+    private:
+    public:
+        /**
+         * Sets the key for the data. If no key is provided, Spider generates a key.
+         * @param key of the data
+         */
+        auto key(std::string const& key) -> Data<T>::Builder&;
+        /**
+         * Sets locality list of the data to build.
+         * @param nodes nodes that has locality
+         * @param hard true if the locality list is a hard requirement, false otherwise
+         * @return self
+         */
+        auto locality(std::vector<std::string> const& nodes, bool hard) -> Data<T>::Builder&;
+        /**
+         * Indicates that the data to build is persisted and should not be rollbacked on failure
+         * recovery.
+         * @return self
+         */
+        // Data<T>::Builder Builder& mark_persist(); // Not implemented in milestone 1
+        /**
+         * Defines clean up functions of the data to build.
+         * @param f clean up function of data
+         */
+        auto cleanup(std::function<T const&()> const& f) -> Data<T>::Builder&;
+        /**
+         * Defines rollback functions of the data to build.
+         * @param f rollback function of data
+         */
+        // Not implemented for milestone 1
+        // auto rollback(std::function<const T&()> const& f) -> Data<T>::Builder&;
+        /**
+         * Builds the data. Stores the value of data into storage with locality list, persisted
+         * flag, cleanup and rollback functions.
+         * @param t value of the data
+         * @return data object
+         */
+        auto build(T const& /*t*/) -> Data<T>;
+    };
+};
+
+}  // namespace spider
+
+#endif  // SPIDER_CLIENT_DATA_HPP

src/spider/client/Future.cpp

@@ -0,0 +1,30 @@
+#include "Future.hpp"
+
+#include <boost/uuid/uuid.hpp>
+#include <boost/uuid/uuid_io.hpp>
+#include <string>
+
+namespace spider {
+
+class FutureImpl {
+    // Implementation details subject to change
+private:
+    boost::uuids::uuid m_id;
+
+public:
+    auto value() -> std::string { return boost::uuids::to_string(m_id); }
+
+    auto ready() -> bool { return m_id.is_nil(); }
+};
+
+template <class T>
+auto Future<T>::get() -> T {
+    return T();
+}
+
+template <class T>
+auto Future<T>::ready() -> bool {
+    return true;
+}
+
+}  // namespace spider

src/spider/client/Future.hpp

@@ -0,0 +1,31 @@
+#ifndef SPIDER_CLIENT_FUTURE_HPP
+#define SPIDER_CLIENT_FUTURE_HPP
+
+#include <memory>
+
+namespace spider {
+
+class FutureImpl;
+
+template <class T>
+class Future {
+private:
+    std::unique_ptr<FutureImpl> m_impl;
+
+public:
+    /**
+     * Gets the value of the future. Blocks until the value is available.
+     * @return value of the future
+     */
+    auto get() -> T;
+
+    /**
+     * Checks if value of the future is ready.
+     * @return true if future is ready, false otherwise
+     */
+    auto ready() -> bool;
+};
+
+}  // namespace spider
+
+#endif  // SPIDER_CLIENT_FUTURE_HPP

src/spider/client/Spider.hpp

@@ -0,0 +1,45 @@
+#ifndef SPIDER_CLIENT_SPIDER_HPP
+#define SPIDER_CLIENT_SPIDER_HPP
+
+#include <functional>
+#include <string>
+
+// NOLINTBEGIN(misc-include-cleaner)
+#include "Data.hpp"
+#include "Future.hpp"
+#include "Task.hpp"
+#include "TaskGraph.hpp"
+
+// NOLINTEND(misc-include-cleaner)
+
+namespace spider {
+/**
+ * Initializes Spider library
+ */
+void init();
+
+/**
+ * Connects to storage
+ * @param url url of the storage to connect
+ */
+void connect(std::string const& url);
+
+/**
+ * Registers function to Spider
+ * @param function function to register
+ */
+template <class R, class... Args>
+void register_task(std::function<R(Args...)> const& function);
+
+/**
+ * Registers function to Spider with timeout
+ * @param function_name name of the function to register
+ * @param timeout task is considered straggler after timeout ms, and Spider triggers replicate the
+ * task
+ */
+template <class R, class... Args>
+void register_task(std::function<R(Args...)> const& function, float timeout);
+
+}  // namespace spider
+
+#endif  // SPIDER_CLIENT_SPIDER_HPP

src/spider/client/Task.cpp

@@ -0,0 +1,15 @@
+#include "Task.hpp"
+
+#include <optional>
+#include <string>
+
+#include "Data.hpp"
+
+namespace spider {
+
+template <typename T>
+auto get_data(std::string const& /*key*/) -> std::optional<Data<T>> {
+    return std::nullopt;
+}
+
+}  // namespace spider