diff --git a/.gitignore b/.gitignore index 094bd633c..2bdf88c9b 100644 --- a/.gitignore +++ b/.gitignore @@ -8,3 +8,4 @@ build # IDE-related directories and files .idea +cmake-build-debug diff --git a/.gitmodules b/.gitmodules index 09604b153..f8ea5ed07 100644 --- a/.gitmodules +++ b/.gitmodules @@ -4,3 +4,6 @@ [submodule "submodules/Catch2"] path = submodules/Catch2 url = https://github.com/catchorg/Catch2.git +[submodule "submodules/abseil-cpp"] + path = submodules/abseil-cpp + url = https://github.com/abseil/abseil-cpp.git diff --git a/CMakeLists.txt b/CMakeLists.txt index d6ab6a8b9..ed5b1d1f0 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -77,6 +77,17 @@ else() endif() message(STATUS "Building using ${SPIDER_LIBS_STRING} libraries") +# Find and setup Boost Library +if(SPIDER_USE_STATIC_LIBS) + set(Boost_USE_STATIC_LIBS ON) +endif() +find_package(Boost 1.74 REQUIRED) +if(Boost_FOUND) + message(STATUS "Found Boost ${Boost_VERSION}") +else() + message(FATAL_ERROR "Could not find ${SPIDER_LIBS_STRING} libraries for Boost") +endif() + # Find and setup fmt find_package(fmt 8.0.1 REQUIRED) if(fmt_FOUND) @@ -106,7 +117,7 @@ else() endif() # Find and setup MariaDBClient library -if(CLP_USE_STATIC_LIBS) +if(SPIDER_USE_STATIC_LIBS) # NOTE: We can't statically link to MariaDBClient since it's GPL message(AUTHOR_WARNING "MariaDBClient cannot be statically linked due to its license.") endif() @@ -114,9 +125,13 @@ find_package(MariaDBClient 3.1.0 REQUIRED) if(MariaDBClient_FOUND) message(STATUS "Found MariaDBClient ${MariaDBClient_VERSION}") else() - message(FATAL_ERROR "Could not find ${CLP_LIBS_STRING} libraries for MariaDBClient") + message(FATAL_ERROR "Could not find ${SPIDER_LIBS_STRING} libraries for MariaDBClient") endif() +# Add abseil-cpp +set(ABSL_PROPAGATE_CXX_STD ON) +add_subdirectory(submodules/abseil-cpp EXCLUDE_FROM_ALL) + find_package(Threads REQUIRED) add_subdirectory(src/spider) diff --git a/src/spider/CMakeLists.txt b/src/spider/CMakeLists.txt index 5e1d2363d..33370968d 100644 --- a/src/spider/CMakeLists.txt +++ b/src/spider/CMakeLists.txt @@ -1,6 +1,16 @@ # set variable as CACHE INTERNAL to access it from other scope -set(SPIDER_CORE_SOURCES storage/MetadataStorage.hpp CACHE INTERNAL "spider core source files") - +set(SPIDER_CORE_SOURCES + 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" +) set(SPIDER_WORKER_SOURCES worker/worker.cpp CACHE INTERNAL "spider worker source files") add_executable(spider_worker) @@ -11,4 +21,9 @@ target_sources( ${SPIDER_CORE_SOURCES} ${SPIDER_WORKER_SOURCES} ) +target_link_libraries( + spider_worker + Boost::boost + absl::flat_hash_map +) add_executable(spider::worker ALIAS spider_worker) diff --git a/src/spider/core/Data.hpp b/src/spider/core/Data.hpp new file mode 100644 index 000000000..37348bb7e --- /dev/null +++ b/src/spider/core/Data.hpp @@ -0,0 +1,35 @@ +#ifndef SPIDER_CORE_DATA_HPP +#define SPIDER_CORE_DATA_HPP + +#include +#include +#include +#include +#include + +class Data { +private: + boost::uuids::uuid m_id; + std::optional m_key; + std::string m_value; + + void init_id() { + boost::uuids::random_generator gen; + m_id = gen(); + } + +public: + explicit Data(std::string value) : m_value(std::move(value)) { init_id(); } + + Data(std::string key, std::string value) : m_key(std::move(key)), m_value(std::move(value)) { + init_id(); + } + + [[nodiscard]] auto get_id() const -> boost::uuids::uuid { return m_id; } + + [[nodiscard]] auto get_key() const -> std::optional { return m_key; } + + [[nodiscard]] auto get_value() const -> std::string { return m_value; } +}; + +#endif // SPIDER_CORE_DATA_HPP diff --git a/src/spider/core/Error.hpp b/src/spider/core/Error.hpp new file mode 100644 index 000000000..6a7c78680 --- /dev/null +++ b/src/spider/core/Error.hpp @@ -0,0 +1,31 @@ +#ifndef SPIDER_CORE_ERROR_HPP +#define SPIDER_CORE_ERROR_HPP + +#include +#include +#include + +namespace spider::core { +enum class StorageErrType : std::uint8_t { + Success = 0, + ConnectionErr, + DbNotFound, + KeyNotFoundErr, + DuplicateKeyErr, + ConstraintViolationErr +}; + +struct StorageErr { + StorageErrType type; + std::string description; + + StorageErr() : type(StorageErrType::Success) {} + + StorageErr(StorageErrType type, std::string description) + : type(type), + description(std::move(description)) {} +}; + +} // namespace spider::core + +#endif // SPIDER_CORE_ERROR_HPP diff --git a/src/spider/core/Task.hpp b/src/spider/core/Task.hpp new file mode 100644 index 000000000..71330de18 --- /dev/null +++ b/src/spider/core/Task.hpp @@ -0,0 +1,135 @@ +#ifndef SPIDER_CORE_TASK_HPP +#define SPIDER_CORE_TASK_HPP + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace spider::core { + +class TaskInput { +private: + std::optional> m_task_output; + std::optional m_value; + std::optional m_data_id; + std::string m_type; + +public: + TaskInput(boost::uuids::uuid output_task_id, std::uint8_t position, std::string type) + : m_task_output({output_task_id, position}), + m_type(std::move(type)) {}; + TaskInput(std::string value, std::string type) + : m_value(std::move(value)), + m_type(std::move(type)) {}; + TaskInput(boost::uuids::uuid data_id, std::string type) + : m_data_id(data_id), + m_type(std::move(type)) {}; + + [[nodiscard]] auto get_task_output( + ) const -> std::optional> { + return m_task_output; + } + + [[nodiscard]] auto get_value() const -> std::optional { return m_value; } + + [[nodiscard]] auto get_data_id() const -> std::optional { + return m_data_id; + } + + [[nodiscard]] auto get_type() const -> std::string { return m_type; } +}; + +class TaskOutput { +private: + std::optional m_value; + std::optional m_data_id; + std::string m_type; + +public: + TaskOutput(std::string value, std::string type) + : m_value(std::move(value)), + m_type(std::move(type)) {} + + TaskOutput(boost::uuids::uuid data_id, std::string type) + : m_data_id(data_id), + m_type(std::move(type)) {} + + [[nodiscard]] auto get_value() const -> std::optional { return m_value; } + + [[nodiscard]] auto get_data_id() const -> std::optional { + return m_data_id; + } + + [[nodiscard]] auto get_type() const -> std::string { return m_type; } +}; + +class TaskInstance {}; + +enum class TaskState : std::uint8_t { + Pending, + Ready, + Running, + Succeed, + Failed, + Canceled, +}; + +enum class TaskCreatorType : std::uint8_t { + Client = 0, + Task, +}; + +class Task { +private: + boost::uuids::uuid m_id; + std::string m_function_name; + TaskState m_state = TaskState::Pending; + TaskCreatorType m_creator_type; + boost::uuids::uuid m_creator_id; + float m_timeout = 0; + std::vector m_inputs; + std::vector m_outputs; + +public: + Task(std::string function_name, TaskCreatorType creator_type, boost::uuids::uuid creator_id) + : m_function_name(std::move(function_name)), + m_creator_type(creator_type), + m_creator_id(creator_id) { + boost::uuids::random_generator gen; + m_id = gen(); + } + + void add_input(TaskInput const& input) { m_inputs.emplace_back(input); } + + void add_output(TaskOutput const& output) { m_outputs.emplace_back(output); } + + [[nodiscard]] auto get_id() const -> boost::uuids::uuid { return m_id; } + + [[nodiscard]] auto get_function_name() const -> std::string { return m_function_name; } + + [[nodiscard]] auto get_state() const -> TaskState { return m_state; } + + [[nodiscard]] auto get_creator_type() const -> TaskCreatorType { return m_creator_type; } + + [[nodiscard]] auto get_creator_id() const -> boost::uuids::uuid { return m_creator_id; } + + [[nodiscard]] auto get_timeout() const -> float { return m_timeout; } + + [[nodiscard]] auto get_num_inputs() const -> size_t { return m_inputs.size(); } + + [[nodiscard]] auto get_num_outputs() const -> size_t { return m_outputs.size(); } + + [[nodiscard]] auto get_input(uint64_t index) const -> TaskInput { return m_inputs[index]; } + + [[nodiscard]] auto get_output(uint64_t index) const -> TaskOutput { return m_outputs[index]; } +}; + +} // namespace spider::core + +#endif // SPIDER_CORE_TASK_HPP diff --git a/src/spider/core/TaskGraph.hpp b/src/spider/core/TaskGraph.hpp new file mode 100644 index 000000000..019b40edf --- /dev/null +++ b/src/spider/core/TaskGraph.hpp @@ -0,0 +1,79 @@ +#ifndef SPIDER_CORE_TASKGRAPH_HPP +#define SPIDER_CORE_TASKGRAPH_HPP + +#include + +#include +#include +#include +#include + +#include "Task.hpp" + +namespace spider::core { + +class TaskGraph { +private: + absl::flat_hash_map m_tasks; + std::vector> m_dependencies; + +public: + auto add_child_task(Task const& task, std::vector const& parents) -> bool { + boost::uuids::uuid const task_id = task.get_id(); + for (boost::uuids::uuid const parent_id : parents) { + if (!m_tasks.contains(parent_id)) { + return false; + } + } + if (m_tasks.contains(task.get_id())) { + return false; + } + + m_tasks.emplace(task_id, task); + for (boost::uuids::uuid const parent_id : parents) { + m_dependencies.emplace_back(parent_id, task_id); + } + return true; + } + + [[nodiscard]] auto get_task(boost::uuids::uuid id) const -> std::optional { + if (m_tasks.contains(id)) { + return m_tasks.at(id); + } + return std::nullopt; + } + + [[nodiscard]] auto get_child_tasks(boost::uuids::uuid id + ) const -> std::vector { + std::vector children; + for (std::pair const dep : m_dependencies) { + if (dep.first == id) { + children.emplace_back(dep.second); + } + } + return children; + } + + [[nodiscard]] auto get_parent_tasks(boost::uuids::uuid id + ) const -> std::vector { + std::vector parents; + for (std::pair const dep : m_dependencies) { + if (dep.second == id) { + parents.emplace_back(dep.first); + } + } + return parents; + } + + [[nodiscard]] auto get_tasks() const -> absl::flat_hash_map const& { + return m_tasks; + } + + [[nodiscard]] auto get_dependencies( + ) const -> std::vector> const& { + return m_dependencies; + } +}; +} // namespace spider::core + +#endif // SPIDER_CORE_TASKGRAPH_HPP diff --git a/src/spider/storage/DataStorage.hpp b/src/spider/storage/DataStorage.hpp new file mode 100644 index 000000000..e03357109 --- /dev/null +++ b/src/spider/storage/DataStorage.hpp @@ -0,0 +1,36 @@ +#ifndef SPIDER_STORAGE_DATASTORAGE_HPP +#define SPIDER_STORAGE_DATASTORAGE_HPP + +#include +#include + +#include "../core/Data.hpp" +#include "../core/Error.hpp" + +namespace spider::core { +class DataStorage { +public: + DataStorage(DataStorage const&) = default; + DataStorage(DataStorage&&) = default; + auto operator=(DataStorage const&) -> DataStorage& = default; + auto operator=(DataStorage&&) -> DataStorage& = default; + virtual ~DataStorage() = default; + + virtual auto connect(std::string url, boost::uuids::uuid id) -> StorageErr = 0; + virtual void close() = 0; + virtual auto initialize() -> StorageErr = 0; + + virtual auto add_data(Data const& data) -> StorageErr = 0; + virtual auto get_data(boost::uuids::uuid id, Data& data) -> StorageErr = 0; + virtual auto add_task_reference(boost::uuids::uuid id, boost::uuids::uuid task_id) -> StorageErr + = 0; + virtual auto + remove_task_reference(boost::uuids::uuid id, boost::uuids::uuid task_id) -> StorageErr = 0; + virtual auto + add_driver_reference(boost::uuids::uuid id, boost::uuids::uuid driver_id) -> StorageErr = 0; + virtual auto + remove_driver_reference(boost::uuids::uuid id, boost::uuids::uuid driver_id) -> StorageErr = 0; +}; +} // namespace spider::core + +#endif // SPIDER_STORAGE_DATASTORAGE_HPP diff --git a/src/spider/storage/MetadataStorage.hpp b/src/spider/storage/MetadataStorage.hpp index c71dc170d..5c0b30a4c 100644 --- a/src/spider/storage/MetadataStorage.hpp +++ b/src/spider/storage/MetadataStorage.hpp @@ -1,4 +1,45 @@ -#ifndef SPIDER_METADATASTORAGE_HPP -#define SPIDER_METADATASTORAGE_HPP +#ifndef SPIDER_STORAGE_METADATASTORAGE_HPP +#define SPIDER_STORAGE_METADATASTORAGE_HPP -#endif // SPIDER_METADATASTORAGE_HPP +#include +#include +#include + +#include "../core/Error.hpp" +#include "../core/Task.hpp" +#include "../core/TaskGraph.hpp" + +namespace spider::core { +class MetadataStorage { +public: + MetadataStorage(MetadataStorage const&) = default; + MetadataStorage(MetadataStorage&&) = default; + auto operator=(MetadataStorage const&) -> MetadataStorage& = default; + auto operator=(MetadataStorage&&) -> MetadataStorage& = default; + virtual ~MetadataStorage() = default; + + virtual auto connect(std::string url, boost::uuids::uuid id) -> StorageErr = 0; + virtual void close() = 0; + virtual auto initialize() -> StorageErr = 0; + + virtual auto add_task_graph(TaskGraph const& task_graph) -> StorageErr = 0; + virtual auto get_task_graph(boost::uuids::uuid id, TaskGraph& task_graph) -> StorageErr = 0; + virtual auto get_task_graphs(std::vector& task_graphs) -> StorageErr = 0; + virtual auto remove_task_graph(boost::uuids::uuid id) -> StorageErr = 0; + virtual auto add_child(boost::uuids::uuid parent_id, Task const& child) -> StorageErr = 0; + virtual auto get_task(boost::uuids::uuid id, Task& task) -> StorageErr = 0; + virtual auto get_ready_tasks(std::vector& tasks) -> StorageErr = 0; + virtual auto set_task_state(boost::uuids::uuid id, TaskState state) -> StorageErr = 0; + virtual auto add_task_instance(TaskInstance const& instance) -> StorageErr = 0; + virtual auto task_finish(TaskInstance const& instance) -> StorageErr = 0; + virtual auto get_task_timeout(std::vector& tasks) -> StorageErr = 0; + virtual auto get_child_task(boost::uuids::uuid id, Task& child) -> StorageErr = 0; + virtual auto get_parent_tasks(boost::uuids::uuid id, std::vector& tasks) -> StorageErr + = 0; + + virtual auto update_heartbeat(boost::uuids::uuid id) -> StorageErr = 0; + virtual auto heartbeat_timeout(std::vector& ids) -> StorageErr = 0; +}; + +} // namespace spider::core +#endif // SPIDER_STORAGE_METADATASTORAGE_HPP diff --git a/src/spider/storage/MysqlStorage.cpp b/src/spider/storage/MysqlStorage.cpp new file mode 100644 index 000000000..04641ad9c --- /dev/null +++ b/src/spider/storage/MysqlStorage.cpp @@ -0,0 +1,131 @@ +#include "MysqlStorage.hpp" + +#include +#include +#include + +#include "../core/Data.hpp" +#include "../core/Error.hpp" +#include "../core/Task.hpp" +#include "../core/TaskGraph.hpp" + +namespace spider::core { +auto MySqlMetadataStorage::connect(std::string /*url*/, boost::uuids::uuid /*id*/) -> StorageErr { + return StorageErr{}; +} + +void MySqlMetadataStorage::close() {} + +auto MySqlMetadataStorage::initialize() -> StorageErr { + return StorageErr{}; +} + +auto MySqlMetadataStorage::add_task_graph(TaskGraph const& /*task_graph*/) -> StorageErr { + return StorageErr{}; +} + +auto MySqlMetadataStorage::get_task_graph(boost::uuids::uuid /*id*/, TaskGraph& /*task_graph*/) + -> StorageErr { + return StorageErr{}; +} + +auto MySqlMetadataStorage::get_task_graphs(std::vector& /*task_graphs*/) -> StorageErr { + return StorageErr{}; +} + +auto MySqlMetadataStorage::remove_task_graph(boost::uuids::uuid /*id*/) -> StorageErr { + return StorageErr{}; +} + +auto MySqlMetadataStorage::add_child(boost::uuids::uuid /*parent_id*/, Task const& /*child*/) + -> StorageErr { + return StorageErr{}; +} + +auto MySqlMetadataStorage::get_task(boost::uuids::uuid /*id*/, Task& /*task*/) -> StorageErr { + return StorageErr{}; +} + +auto MySqlMetadataStorage::get_ready_tasks(std::vector& /*tasks*/) -> StorageErr { + return StorageErr{}; +} + +auto MySqlMetadataStorage::set_task_state(boost::uuids::uuid /*id*/, TaskState /*state*/) + -> StorageErr { + return StorageErr{}; +} + +auto MySqlMetadataStorage::add_task_instance(TaskInstance const& /*instance*/) -> StorageErr { + return StorageErr{}; +} + +auto MySqlMetadataStorage::task_finish(TaskInstance const& /*instance*/) -> StorageErr { + return StorageErr{}; +} + +auto MySqlMetadataStorage::get_task_timeout(std::vector& /*tasks*/) -> StorageErr { + return StorageErr{}; +} + +auto MySqlMetadataStorage::get_child_task(boost::uuids::uuid /*id*/, Task& /*child*/) + -> StorageErr { + return StorageErr{}; +} + +auto MySqlMetadataStorage::get_parent_tasks(boost::uuids::uuid /*id*/, std::vector& /*tasks*/) + -> StorageErr { + return StorageErr{}; +} + +auto MySqlMetadataStorage::update_heartbeat(boost::uuids::uuid /*id*/) -> StorageErr { + return StorageErr{}; +} + +auto MySqlMetadataStorage::heartbeat_timeout(std::vector& /*ids*/) + -> StorageErr { + return StorageErr{}; +} + +auto MySqlDataStorage::connect(std::string /*url*/, boost::uuids::uuid /*id*/) -> StorageErr { + return StorageErr{}; +} + +void MySqlDataStorage::close() {} + +auto MySqlDataStorage::initialize() -> StorageErr { + return StorageErr{}; +} + +auto MySqlDataStorage::add_data(Data const& /*data*/) -> StorageErr { + return StorageErr{}; +} + +auto MySqlDataStorage::get_data(boost::uuids::uuid /*id*/, Data& /*data*/) -> StorageErr { + return StorageErr{}; +} + +auto MySqlDataStorage::add_task_reference(boost::uuids::uuid /*id*/, boost::uuids::uuid /*task_id*/) + -> StorageErr { + return StorageErr{}; +} + +auto MySqlDataStorage:: + remove_task_reference(boost::uuids::uuid /*id*/, boost::uuids::uuid /*task_id*/) + -> StorageErr { + return StorageErr{}; +} + +auto MySqlDataStorage:: + add_driver_reference(boost::uuids::uuid /*id*/, boost::uuids::uuid /*driver_id*/) + -> StorageErr { + return StorageErr{}; +} + +auto MySqlDataStorage::remove_driver_reference( + boost::uuids::uuid /*id*/, + boost::uuids::uuid /*driver_id*/ +) -> StorageErr { + return StorageErr{}; +} + +} // namespace spider::core diff --git a/src/spider/storage/MysqlStorage.hpp b/src/spider/storage/MysqlStorage.hpp new file mode 100644 index 000000000..a577b5e98 --- /dev/null +++ b/src/spider/storage/MysqlStorage.hpp @@ -0,0 +1,66 @@ +#ifndef SPIDER_STORAGE_MYSQLSTORAGE_HPP +#define SPIDER_STORAGE_MYSQLSTORAGE_HPP + +#include +#include +#include + +#include "../core/Data.hpp" +#include "../core/Error.hpp" +#include "../core/Task.hpp" +#include "../core/TaskGraph.hpp" +#include "DataStorage.hpp" +#include "MetadataStorage.hpp" + +namespace spider::core { +class MySqlMetadataStorage : public MetadataStorage { +public: + MySqlMetadataStorage(MySqlMetadataStorage const&) = delete; + MySqlMetadataStorage(MySqlMetadataStorage&&) = delete; + auto operator=(MySqlMetadataStorage const&) -> MySqlMetadataStorage& = delete; + auto operator=(MySqlMetadataStorage&&) -> MySqlMetadataStorage& = delete; + ~MySqlMetadataStorage() override = default; + auto connect(std::string url, boost::uuids::uuid id) -> StorageErr override; + void close() override; + auto initialize() -> StorageErr override; + auto add_task_graph(TaskGraph const& task_graph) -> StorageErr override; + auto get_task_graph(boost::uuids::uuid id, TaskGraph& task_graph) -> StorageErr override; + auto get_task_graphs(std::vector& task_graphs) -> StorageErr override; + auto remove_task_graph(boost::uuids::uuid id) -> StorageErr override; + auto add_child(boost::uuids::uuid parent_id, Task const& child) -> StorageErr override; + auto get_task(boost::uuids::uuid id, Task& task) -> StorageErr override; + auto get_ready_tasks(std::vector& tasks) -> StorageErr override; + auto set_task_state(boost::uuids::uuid id, TaskState state) -> StorageErr override; + auto add_task_instance(TaskInstance const& instance) -> StorageErr override; + auto task_finish(TaskInstance const& instance) -> StorageErr override; + auto get_task_timeout(std::vector& tasks) -> StorageErr override; + auto get_child_task(boost::uuids::uuid id, Task& child) -> StorageErr override; + auto get_parent_tasks(boost::uuids::uuid id, std::vector& tasks) -> StorageErr override; + auto update_heartbeat(boost::uuids::uuid id) -> StorageErr override; + auto heartbeat_timeout(std::vector& ids) -> StorageErr override; +}; + +class MySqlDataStorage : public DataStorage { +public: + MySqlDataStorage(MySqlDataStorage const&) = delete; + MySqlDataStorage(MySqlDataStorage&&) = delete; + auto operator=(MySqlDataStorage const&) -> MySqlDataStorage& = delete; + auto operator=(MySqlDataStorage&&) -> MySqlDataStorage& = delete; + ~MySqlDataStorage() override = default; + auto connect(std::string url, boost::uuids::uuid id) -> StorageErr override; + void close() override; + auto initialize() -> StorageErr override; + auto add_data(Data const& data) -> StorageErr override; + auto get_data(boost::uuids::uuid id, Data& data) -> StorageErr override; + auto + add_task_reference(boost::uuids::uuid id, boost::uuids::uuid task_id) -> StorageErr override; + auto + remove_task_reference(boost::uuids::uuid id, boost::uuids::uuid task_id) -> StorageErr override; + auto add_driver_reference(boost::uuids::uuid id, boost::uuids::uuid driver_id) + -> StorageErr override; + auto remove_driver_reference(boost::uuids::uuid id, boost::uuids::uuid driver_id) + -> StorageErr override; +}; +} // namespace spider::core + +#endif // SPIDER_STORAGE_MYSQLSTORAGE_HPP diff --git a/submodules/abseil-cpp b/submodules/abseil-cpp new file mode 160000 index 000000000..07fff76ed --- /dev/null +++ b/submodules/abseil-cpp @@ -0,0 +1 @@ +Subproject commit 07fff76ed619672bb7bf00939231ba45aef2b043 diff --git a/tools/scripts/lib_install/boost.sh b/tools/scripts/lib_install/boost.sh new file mode 100755 index 000000000..19a1e445a --- /dev/null +++ b/tools/scripts/lib_install/boost.sh @@ -0,0 +1,46 @@ +#!/usr/bin/env bash + +# Exit on error +set -e + +cUsage="Usage: ${BASH_SOURCE[0]} " +if [ "$#" -lt 1 ] ; then + echo $cUsage + exit +fi +version=$1 +version_with_underscores=${version//./_} + +echo "Checking for elevated privileges..." +privileged_command_prefix="" +if [ ${EUID:-$(id -u)} -ne 0 ] ; then + sudo echo "Script can elevate privileges." + privileged_command_prefix="${privileged_command_prefix} sudo" +fi + +# Get number of cpu cores +num_cpus=$(grep -c ^processor /proc/cpuinfo) + +package_name=boost + +# Create temp dir for installation +temp_dir=/tmp/${package_name}-installation +mkdir -p $temp_dir + +cd $temp_dir + +# Download source +tar_filename=boost_${version_with_underscores}.tar.gz +curl -fsSL https://boostorg.jfrog.io/artifactory/main/release/${version}/source/${tar_filename} -o ${tar_filename} +tar xzf ${tar_filename} +cd boost_${version_with_underscores} + +# Build +./bootstrap.sh --with-libraries=filesystem,iostreams,program_options,regex,system +./b2 -j${num_cpus} + +# Install +${privileged_command_prefix} ./b2 install + +# Clean up +${privileged_command_prefix} rm -rf $temp_dir \ No newline at end of file diff --git a/tools/scripts/linux/install-lib.sh b/tools/scripts/linux/install-lib.sh index eca3c1d35..b49a20bbe 100755 --- a/tools/scripts/linux/install-lib.sh +++ b/tools/scripts/linux/install-lib.sh @@ -12,3 +12,4 @@ lib_install_scripts_dir=$script_dir/.. "$lib_install_scripts_dir"/lib_install/fmtlib.sh 11.0.2 "$lib_install_scripts_dir"/lib_install/spdlog.sh 1.14.1 "$lib_install_scripts_dir"/lib_install/mariadb-connector-c.sh 3.4.1 +"$lib_install_scripts_dir"/lib_install/boost.sh 1.86.0