job_requirements: Refactor away std::unique_ptr<storage> arg (f6afefcb) · Commits · eu / ADMIRE / scord

src/common/api/admire_types.hpp

+19 −5

Original line number	Diff line number	Diff line
		@@ -389,7 +389,7 @@ struct job_requirements {

		job_requirements(std::vector<admire::dataset> inputs,
		std::vector<admire::dataset> outputs,
		std::unique_ptr<storage> storage);
		admire::adhoc_storage adhoc_storage);

		explicit job_requirements(ADM_job_requirements_t reqs);

		@@ -406,8 +406,8 @@ struct job_requirements {
		inputs() const;
		std::vector<admire::dataset>
		outputs() const;
		std::shared_ptr<admire::storage>
		storage() const;
		std::optional<admire::adhoc_storage>
		adhoc_storage() const;

		private:
		class impl;
		@@ -632,6 +632,20 @@ struct fmt::formatter<std::optional<std::uint64_t>>
		}
		};

		template <>
		struct fmt::formatter<std::optional<admire::adhoc_storage>>
		: formatter<std::string_view> {

		// parse is inherited from formatter<string_view>.
		template <typename FormatContext>
		auto
		format(const std::optional<admire::adhoc_storage>& v,
		FormatContext& ctx) const {
		return formatter<std::string_view>::format(
		v ? fmt::format("{}", v.value()) : "none", ctx);
		}
		};

		template <>
		struct fmt::formatter<admire::adhoc_storage> : formatter<std::string_view> {
		// parse is inherited from formatter<string_view>.
		@@ -729,8 +743,8 @@ struct fmt::formatter<admire::job_requirements> : formatter<std::string_view> {
		auto
		format(const admire::job_requirements& r, FormatContext& ctx) const {
		return formatter<std::string_view>::format(
		fmt::format("{{inputs: {}, outputs: {}, storage: {}}}",
		r.inputs(), r.outputs(), r.storage()),
		fmt::format("{{inputs: {}, outputs: {}, adhoc_storage: {}}}",
		r.inputs(), r.outputs(), r.adhoc_storage()),
		ctx);
		}
		};

src/common/api/convert.cpp

+19 −2

Original line number	Diff line number	Diff line
		@@ -96,6 +96,24 @@ convert(const adhoc_storage::ctx& ctx) {
		std::move(managed_adhoc_resources)};
		}

		managed_ctype<ADM_storage_t>
		convert(const std::optional<admire::adhoc_storage>& adhoc_storage) {

		if(!adhoc_storage) {
		return managed_ctype<ADM_storage_t>{};
		}

		auto managed_ctx =
		convert(*std::static_pointer_cast<admire::adhoc_storage::ctx>(
		adhoc_storage->context()));
		ADM_storage_t c_st = ADM_storage_create(
		adhoc_storage->user_id().c_str(),
		static_cast<ADM_storage_type_t>(adhoc_storage->type()),
		managed_ctx.get());

		return managed_ctype<ADM_storage_t>{c_st, std::move(managed_ctx)};
		}

		managed_ctype<ADM_storage_t>
		convert(const admire::adhoc_storage& st) {

		@@ -174,8 +192,7 @@ convert(const job::resources& res) {
		managed_ctype<ADM_job_requirements_t>
		convert(const admire::job_requirements& reqs) {

		const auto& adhoc_storage =
		*std::dynamic_pointer_cast<admire::adhoc_storage>(reqs.storage());
		const auto& adhoc_storage = reqs.adhoc_storage();

		auto managed_storage = convert(adhoc_storage);
		auto managed_inputs = as_ctype_array(reqs.inputs());

src/common/api/convert.hpp

+8 −0

Original line number	Diff line number	Diff line
		@@ -118,6 +118,8 @@ struct admire::api::managed_ctype<ADM_node_t> {
		template <>
		struct admire::api::managed_ctype_array<ADM_node_t> {

		managed_ctype_array() = default;

		explicit managed_ctype_array(ADM_node_t* data, size_t size)
		: m_nodes(data, size) {}

		@@ -150,6 +152,8 @@ struct admire::api::managed_ctype_array<ADM_node_t> {
		template <>
		struct admire::api::managed_ctype<ADM_adhoc_resources_t> {

		managed_ctype() = default;

		explicit managed_ctype(ADM_adhoc_resources_t res,
		managed_ctype_array<ADM_node_t>&& nodes)
		: m_adhoc_resources(res), m_nodes(std::move(nodes)) {}
		@@ -172,6 +176,8 @@ struct admire::api::managed_ctype<ADM_adhoc_resources_t> {
		template <>
		struct admire::api::managed_ctype<ADM_adhoc_context_t> {

		managed_ctype() = default;

		explicit managed_ctype(ADM_adhoc_context_t ctx,
		managed_ctype<ADM_adhoc_resources_t>&& resources)
		: m_adhoc_context(ctx), m_adhoc_resources(std::move(resources)) {}
		@@ -194,6 +200,8 @@ struct admire::api::managed_ctype<ADM_adhoc_context_t> {
		template <>
		struct admire::api::managed_ctype<ADM_storage_t> {

		managed_ctype() = default;

		explicit managed_ctype(ADM_storage_t st,
		managed_ctype<ADM_adhoc_context_t>&& ctx)
		: m_storage(st), m_ctx(std::move(ctx)) {}

src/common/api/types.cpp

+15 −32

Original line number	Diff line number	Diff line
		@@ -1469,9 +1469,10 @@ public:

		impl(std::vector<admire::dataset> inputs,
		std::vector<admire::dataset> outputs,
		std::unique_ptr<admire::storage> storage)
		admire::adhoc_storage adhoc_storage)
		: m_inputs(std::move(inputs)), m_outputs(std::move(outputs)),
		m_storage(std::move(storage)) {}
		m_adhoc_storage(std::move(adhoc_storage)) {}


		explicit impl(ADM_job_requirements_t reqs) {
		m_inputs.reserve(reqs->r_inputs->l_length);
		@@ -1487,27 +1488,9 @@ public:
		}

		if(reqs->r_storage) {

		switch(reqs->r_storage->s_type) {

		case ADM_STORAGE_GEKKOFS:
		case ADM_STORAGE_DATACLAY:
		case ADM_STORAGE_EXPAND:
		case ADM_STORAGE_HERCULES:
		m_storage = std::make_unique<adhoc_storage>(
		static_cast<enum storage::type>(
		reqs->r_storage->s_type),
		reqs->r_storage->s_id,
		reqs->r_storage->s_adhoc_ctx);
		break;
		case ADM_STORAGE_LUSTRE:
		case ADM_STORAGE_GPFS:
		m_storage = std::make_unique<pfs_storage>(
		static_cast<enum storage::type>(
		reqs->r_storage->s_type),
		reqs->r_storage->s_id, reqs->r_storage->s_pfs_ctx);
		break;
		}
		m_adhoc_storage = admire::adhoc_storage(
		static_cast<enum storage::type>(reqs->r_storage->s_type),
		reqs->r_storage->s_id, reqs->r_storage->s_adhoc_ctx);
		}
		}

		@@ -1528,15 +1511,15 @@ public:
		return m_outputs;
		}

		std::shared_ptr<admire::storage>
		storage() const {
		return m_storage;
		std::optional<admire::adhoc_storage>
		adhoc_storage() const {
		return m_adhoc_storage;
		}

		private:
		std::vector<admire::dataset> m_inputs;
		std::vector<admire::dataset> m_outputs;
		std::shared_ptr<admire::storage> m_storage;
		std::optional<admire::adhoc_storage> m_adhoc_storage;
		};


		@@ -1546,9 +1529,9 @@ job_requirements::job_requirements(std::vector<admire::dataset> inputs,

		job_requirements::job_requirements(std::vector<admire::dataset> inputs,
		std::vector<admire::dataset> outputs,
		std::unique_ptr<admire::storage> storage)
		admire::adhoc_storage adhoc_storage)
		: m_pimpl(std::make_unique<impl>(std::move(inputs), std::move(outputs),
		std::move(storage))) {}
		std::move(adhoc_storage))) {}

		job_requirements::job_requirements(ADM_job_requirements_t reqs)
		: m_pimpl(std::make_unique<impl>(reqs)) {}
		@@ -1579,9 +1562,9 @@ job_requirements::outputs() const {
		return m_pimpl->outputs();
		}

		std::shared_ptr<admire::storage>
		job_requirements::storage() const {
		return m_pimpl->storage();
		std::optional<admire::adhoc_storage>
		job_requirements::adhoc_storage() const {
		return m_pimpl->adhoc_storage();
		}

		namespace qos {