examples/c/ADM_transfer_datasets.c

@@ -73,9 +73,9 @@ main(int argc, char* argv[]) {
 
     const char* name = "adhoc_storage_42";
 
-    ADM_storage_t adhoc_storage;
+    ADM_adhoc_storage_t adhoc_storage;
     ADM_return_t ret = ADM_register_adhoc_storage(
-            server, name, ADM_STORAGE_GEKKOFS, ctx, &adhoc_storage);
+            server, name, ADM_ADHOC_STORAGE_GEKKOFS, ctx, &adhoc_storage);
 
     if(ret != ADM_SUCCESS) {
         fprintf(stderr,

examples/c/ADM_update_adhoc_storage.c

@@ -51,7 +51,7 @@ main(int argc, char* argv[]) {
     ADM_adhoc_resources_t adhoc_resources = NULL;
     ADM_adhoc_context_t adhoc_ctx = NULL;
     ADM_adhoc_context_t new_adhoc_ctx = NULL;
-    ADM_storage_t adhoc_storage = NULL;
+    ADM_adhoc_storage_t adhoc_storage = NULL;
 
 
     // Let's prepare all the information required by the API calls.
@@ -96,7 +96,7 @@ main(int argc, char* argv[]) {
     }
 
     // 2. Register the adhoc storage
-    if(ADM_register_adhoc_storage(server, adhoc_name, ADM_STORAGE_GEKKOFS,
+    if(ADM_register_adhoc_storage(server, adhoc_name, ADM_ADHOC_STORAGE_GEKKOFS,
                                   adhoc_ctx, &adhoc_storage) != ADM_SUCCESS) {
         fprintf(stderr, "ADM_register_adhoc_storage() failed: %s\n",
                 ADM_strerror(ret));

examples/c/ADM_update_job.c

@@ -70,9 +70,9 @@ main(int argc, char* argv[]) {
 
     const char* name = "adhoc_storage_42";
 
-    ADM_storage_t adhoc_storage;
+    ADM_adhoc_storage_t adhoc_storage;
     ADM_return_t ret = ADM_register_adhoc_storage(
-            server, name, ADM_STORAGE_GEKKOFS, ctx, &adhoc_storage);
+            server, name, ADM_ADHOC_STORAGE_GEKKOFS, ctx, &adhoc_storage);
 
     if(ret != ADM_SUCCESS) {
         fprintf(stderr,

examples/c/ADM_update_pfs_storage.c

@@ -42,7 +42,7 @@ main(int argc, char* argv[]) {
     ADM_pfs_context_t ctx = ADM_pfs_context_create("/gpfs");
     assert(ctx);
 
-    ADM_storage_t pfs_storage;
+    ADM_pfs_storage_t pfs_storage;
     ADM_return_t ret = ADM_register_pfs_storage(server, ctx, &pfs_storage);
 
     if(ret != ADM_SUCCESS) {

examples/cxx/ADM_deploy_adhoc_storage.cpp

@@ -24,7 +24,12 @@
 
 #include <fmt/format.h>
 #include <admire.hpp>
+#include "common.hpp"
 
+#define NJOB_NODES   50
+#define NADHOC_NODES 25
+#define NINPUTS      10
+#define NOUTPUTS     5
 
 int
 main(int argc, char* argv[]) {
@@ -38,21 +43,32 @@ main(int argc, char* argv[]) {
 
     admire::server server{"tcp", argv[1]};
 
-    ADM_storage_t adhoc_storage{};
-    ADM_return_t ret = ADM_SUCCESS;
+    const auto adhoc_nodes = prepare_nodes(NADHOC_NODES);
+    const auto inputs = prepare_datasets("input-dataset-{}", NINPUTS);
+    const auto outputs = prepare_datasets("output-dataset-{}", NOUTPUTS);
+
+    std::string name = "adhoc_storage_42";
+    const auto adhoc_storage_ctx = admire::adhoc_storage::ctx{
+            admire::adhoc_storage::execution_mode::separate_new,
+            admire::adhoc_storage::access_type::read_write,
+            admire::adhoc_storage::resources{adhoc_nodes}, 100, false};
 
     try {
-        ret = admire::deploy_adhoc_storage(server, adhoc_storage);
-    } catch(const std::exception& e) {
-        fmt::print(stderr, "FATAL: ADM_deploy_adhoc_storage() failed: {}\n",
-                   e.what());
-        exit(EXIT_FAILURE);
-    }
+        const auto adhoc_storage = admire::register_adhoc_storage(
+                server, name, admire::adhoc_storage::type::dataclay,
+                adhoc_storage_ctx);
 
-    if(ret != ADM_SUCCESS) {
         fmt::print(stdout,
-                   "ADM_deploy_adhoc_storage() remote procedure not completed "
+                   "ADM_register_adhoc_storage() remote procedure completed "
                    "successfully\n");
+
+        admire::deploy_adhoc_storage(server, adhoc_storage);
+
+    } catch(const std::exception& e) {
+        fmt::print(stderr,
+                   "FATAL: ADM_register_adhoc_storage() or "
+                   "ADM_deploy_adhoc_storage() failed: {}\n",
+                   e.what());
         exit(EXIT_FAILURE);
     }
 

examples/cxx/ADM_register_adhoc_storage.cpp

@@ -55,7 +55,7 @@ main(int argc, char* argv[]) {
 
     try {
         const auto adhoc_storage = admire::register_adhoc_storage(
-                server, name, admire::storage::type::gekkofs,
+                server, name, admire::adhoc_storage::type::gekkofs,
                 adhoc_storage_ctx);
 
         fmt::print(stdout,

examples/cxx/ADM_register_job.cpp

@@ -56,7 +56,7 @@ main(int argc, char* argv[]) {
     try {
 
         const auto adhoc_storage = admire::register_adhoc_storage(
-                server, name, admire::storage::type::gekkofs,
+                server, name, admire::adhoc_storage::type::gekkofs,
                 adhoc_storage_ctx);
 
         admire::job_requirements reqs(inputs, outputs, adhoc_storage);

examples/cxx/ADM_register_pfs_storage.cpp

@@ -39,7 +39,7 @@ main(int argc, char* argv[]) {
     admire::server server{"tcp", argv[1]};
 
     ADM_pfs_context_t ctx{};
-    ADM_storage_t pfs_storage{};
+    ADM_pfs_storage_t pfs_storage{};
     ADM_return_t ret = ADM_SUCCESS;
 
     try {

examples/cxx/ADM_remove_adhoc_storage.cpp

@@ -55,7 +55,7 @@ main(int argc, char* argv[]) {
 
     try {
         const auto adhoc_storage = admire::register_adhoc_storage(
-                server, name, admire::storage::type::gekkofs,
+                server, name, admire::adhoc_storage::type::gekkofs,
                 adhoc_storage_ctx);
         admire::remove_adhoc_storage(server, adhoc_storage);
         fmt::print(stdout,

examples/cxx/ADM_remove_job.cpp

@@ -56,7 +56,7 @@ main(int argc, char* argv[]) {
     try {
 
         const auto adhoc_storage = admire::register_adhoc_storage(
-                server, name, admire::storage::type::gekkofs,
+                server, name, admire::adhoc_storage::type::gekkofs,
                 adhoc_storage_ctx);
 
         admire::job_requirements reqs(inputs, outputs, adhoc_storage);

examples/cxx/ADM_remove_pfs_storage.cpp

@@ -37,7 +37,7 @@ main(int argc, char* argv[]) {
 
     admire::server server{"tcp", argv[1]};
 
-    ADM_storage_t pfs_storage{};
+    ADM_pfs_storage_t pfs_storage{};
     ADM_return_t ret = ADM_SUCCESS;
 
     try {

examples/cxx/ADM_set_io_resources.cpp

@@ -38,7 +38,7 @@ main(int argc, char* argv[]) {
     admire::server server{"tcp", argv[1]};
 
     ADM_job_t job{};
-    ADM_storage_t tier{};
+    ADM_adhoc_storage_t tier{};
     ADM_adhoc_resources_t resources{};
     ADM_return_t ret = ADM_SUCCESS;
 

examples/cxx/ADM_transfer_datasets.cpp

@@ -63,7 +63,7 @@ main(int argc, char* argv[]) {
 
     try {
         const auto adhoc_storage = admire::register_adhoc_storage(
-                server, name, admire::storage::type::gekkofs,
+                server, name, admire::adhoc_storage::type::gekkofs,
                 adhoc_storage_ctx);
 
         admire::job_requirements reqs(inputs, outputs, adhoc_storage);

examples/cxx/ADM_update_adhoc_storage.cpp

@@ -60,7 +60,7 @@ main(int argc, char* argv[]) {
 
     try {
         const auto adhoc_storage = admire::register_adhoc_storage(
-                server, name, admire::storage::type::gekkofs,
+                server, name, admire::adhoc_storage::type::gekkofs,
                 adhoc_storage_ctx);
 
         admire::update_adhoc_storage(server, adhoc_storage,

examples/cxx/ADM_update_job.cpp

@@ -49,7 +49,7 @@ main(int argc, char* argv[]) {
     const auto outputs = prepare_datasets("output-dataset-{}", NOUTPUTS);
 
     const auto gkfs_storage = admire::register_adhoc_storage(
-            server, "foobar", admire::storage::type::gekkofs,
+            server, "foobar", admire::adhoc_storage::type::gekkofs,
             admire::adhoc_storage::ctx{
                     admire::adhoc_storage::execution_mode::separate_new,
                     admire::adhoc_storage::access_type::read_write,

examples/cxx/ADM_update_pfs_storage.cpp

@@ -38,7 +38,7 @@ main(int argc, char* argv[]) {
     admire::server server{"tcp", argv[1]};
 
     ADM_pfs_context_t ctx{};
-    ADM_storage_t pfs_storage{};
+    ADM_pfs_storage_t pfs_storage{};
     ADM_return_t ret = ADM_SUCCESS;
 
     try {

src/common/api/admire_types.h

@@ -108,18 +108,25 @@ typedef struct adm_qos_limit_list* ADM_qos_limit_list_t;
 /*              Storage tiers                            */
 /* ----------------------------------------------------- */
 
-/** Storage tier types */
+/** Adhoc storage tier types */
 typedef enum {
-    ADM_STORAGE_GEKKOFS,
-    ADM_STORAGE_DATACLAY,
-    ADM_STORAGE_EXPAND,
-    ADM_STORAGE_HERCULES,
-    ADM_STORAGE_LUSTRE,
-    ADM_STORAGE_GPFS,
-} ADM_storage_type_t;
+    ADM_ADHOC_STORAGE_GEKKOFS,
+    ADM_ADHOC_STORAGE_DATACLAY,
+    ADM_ADHOC_STORAGE_EXPAND,
+    ADM_ADHOC_STORAGE_HERCULES,
+} ADM_adhoc_storage_type_t;
 
-/** A storage tier */
-typedef struct adm_storage* ADM_storage_t;
+/** Adhoc storage tier types */
+typedef enum {
+    ADM_PFS_STORAGE_LUSTRE,
+    ADM_PFS_STORAGE_GPFS,
+} ADM_pfs_storage_type_t;
+
+/** An adhoc storage tier */
+typedef struct adm_adhoc_storage* ADM_adhoc_storage_t;
+
+/** A PFS storage tier */
+typedef struct adm_pfs_storage* ADM_pfs_storage_t;
 
 /** Information about resources assigned to a storage tier */
 typedef struct adm_adhoc_resources* ADM_adhoc_resources_t;
@@ -314,7 +321,7 @@ ADM_job_resources_destroy(ADM_job_resources_t res);
  * @param[in] outputs An array of DATASET_DESCRIPTORS describing the output
  * information generated by the job.
  * @param[in] outputs_len The number of DATASET_DESCRIPTORS stored in outputs.
- * @param[in] storage An optional ADHOC_DESCRIPTOR describing the adhoc
+ * @param[in] adhoc_storage An optional ADHOC_DESCRIPTOR describing the adhoc
  * storage system required by the job (can be set to NULL if no adhoc storage
  * system is required).
  * @return A valid ADM_job_requirements_t if sucessfull or NULL in case of
@@ -323,7 +330,7 @@ ADM_job_resources_destroy(ADM_job_resources_t res);
 ADM_job_requirements_t
 ADM_job_requirements_create(ADM_dataset_t inputs[], size_t inputs_len,
                             ADM_dataset_t outputs[], size_t outputs_len,
-                            ADM_storage_t storage);
+                            ADM_adhoc_storage_t adhoc_storage);
 
 /**
  * Destroy a ADM_job_requirements_t created by ADM_job_requirements_create().
@@ -411,30 +418,31 @@ ADM_dataset_list_destroy(ADM_dataset_list_t list);
 /* ----------------------------------------------------- */
 
 /**
- * Create a ADM_STORAGE to represent a storage tier.
+ * Create a ADM_ADHOC_STORAGE to represent an adhoc storage tier.
  *
- * @remark ADM_STORAGEs need to be freed by calling ADM_storage_destroy().
+ * @remark ADM_ADHOC_STORAGEs need to be freed by calling
+ * ADM_adhoc_storage_destroy().
  *
  * @param[in] name A name for the storage tier
  * @param[in] type The type for the storage tier being created.
  * @param[in] id The assigned id for the storage tier being created.
- * @param[in] ctx Some specific context information for the storage tier or
- * NULL if none is required. For instance, an adhoc storage system may find it
- * useful to provide an ADM_adhoc_context_t describing the instance.
- * @return A valid ADM_STORAGE if successful, or NULL in case of failure.
+ * @param[in] adhoc_ctx Some specific context information for the storage
+ * tier or NULL if none is required. For instance, an adhoc storage system may
+ * find it useful to provide an ADM_adhoc_context_t describing the instance.
+ * @return A valid ADM_ADHOC_STORAGE if successful, or NULL in case of failure.
  */
-ADM_storage_t
-ADM_storage_create(const char* name, ADM_storage_type_t type, uint64_t id,
-                   void* ctx);
+ADM_adhoc_storage_t
+ADM_adhoc_storage_create(const char* name, ADM_adhoc_storage_type_t type,
+                         uint64_t id, ADM_adhoc_context_t adhoc_ctx);
 
 /**
- * Destroy a ADM_STORAGE created by ADM_storage_destroy().
+ * Destroy an ADM_ADHOC_STORAGE created by ADM_adhoc_storage_destroy().
  *
  * @param[in] storage A valid ADM_STORAGE
  * @return ADM_SUCCESS or corresponding ADM error code
  */
 ADM_return_t
-ADM_storage_destroy(ADM_storage_t storage);
+ADM_adhoc_storage_destroy(ADM_adhoc_storage_t adhoc_storage);
 
 /**
  * Create an ADM_ADHOC_RESOURCES from information about storage resources.
@@ -490,6 +498,33 @@ ADM_adhoc_context_create(ADM_adhoc_mode_t exec_mode,
 ADM_return_t
 ADM_adhoc_context_destroy(ADM_adhoc_context_t ctx);
 
+/**
+ * Create a ADM_PFS_STORAGE to represent a PFS storage tier.
+ *
+ * @remark ADM_PFS_STORAGEs need to be freed by calling
+ * ADM_pfs_storage_destroy().
+ *
+ * @param[in] name A name for the storage tier
+ * @param[in] type The type for the storage tier being created.
+ * @param[in] id The assigned id for the storage tier being created.
+ * @param[in] pfs_ctx Some specific context information for the storage
+ * tier or NULL if none is required. For instance, an adhoc storage system may
+ * find it useful to provide an ADM_adhoc_context_t describing the instance.
+ * @return A valid ADM_ADHOC_STORAGE if successful, or NULL in case of failure.
+ */
+ADM_adhoc_storage_t
+ADM_pfs_storage_create(const char* name, ADM_adhoc_storage_type_t type,
+                       uint64_t id, ADM_adhoc_context_t adhoc_ctx);
+
+/**
+ * Destroy an ADM_ADHOC_STORAGE created by ADM_adhoc_storage_destroy().
+ *
+ * @param[in] storage A valid ADM_STORAGE
+ * @return ADM_SUCCESS or corresponding ADM error code
+ */
+ADM_return_t
+ADM_pfs_storage_destroy(ADM_pfs_storage_t pfs_storage);
+
 /**
  * Create an ADM_PFS_CONTEXT from information about how a PFS is configured.
  *

src/common/api/admire_types.hpp

@@ -310,43 +310,15 @@ private:
     std::unique_ptr<impl> m_pimpl;
 };
 
-struct storage {
-
-    enum class type : std::underlying_type<ADM_storage_type_t>::type {
-        gekkofs = ADM_STORAGE_GEKKOFS,
-        dataclay = ADM_STORAGE_DATACLAY,
-        expand = ADM_STORAGE_EXPAND,
-        hercules = ADM_STORAGE_HERCULES,
-        lustre = ADM_STORAGE_LUSTRE,
-        gpfs = ADM_STORAGE_GPFS
-    };
+struct adhoc_storage {
 
-    struct ctx {
-        virtual ~ctx() = default;
+    enum class type : std::underlying_type<ADM_adhoc_storage_type_t>::type {
+        gekkofs = ADM_ADHOC_STORAGE_GEKKOFS,
+        dataclay = ADM_ADHOC_STORAGE_DATACLAY,
+        expand = ADM_ADHOC_STORAGE_EXPAND,
+        hercules = ADM_ADHOC_STORAGE_HERCULES,
     };
 
-    storage(storage::type type, std::string name, std::uint64_t id);
-
-    virtual ~storage() = default;
-
-    std::string
-    name() const;
-    type
-    type() const;
-    std::uint64_t
-    id() const;
-
-    virtual std::shared_ptr<ctx>
-    context() const = 0;
-
-protected:
-    std::string m_name;
-    enum type m_type;
-    std::uint64_t m_id;
-};
-
-struct adhoc_storage : public storage {
-
     enum class execution_mode : std::underlying_type<ADM_adhoc_mode_t>::type {
         in_job_shared = ADM_ADHOC_MODE_IN_JOB_SHARED,
         in_job_dedicated = ADM_ADHOC_MODE_IN_JOB_DEDICATED,
@@ -371,7 +343,7 @@ struct adhoc_storage : public storage {
         std::vector<admire::node> m_nodes;
     };
 
-    struct ctx : storage::ctx {
+    struct ctx {
 
         ctx(execution_mode exec_mode, access_type access_type,
             adhoc_storage::resources resources, std::uint32_t walltime,
@@ -398,15 +370,13 @@ struct adhoc_storage : public storage {
         bool m_should_flush;
     };
 
-    adhoc_storage(enum storage::type type, std::string name, std::uint64_t id,
-                  execution_mode exec_mode, access_type access_type,
-                  adhoc_storage::resources res, std::uint32_t walltime,
-                  bool should_flush);
-    explicit adhoc_storage(ADM_storage_t storage);
-    adhoc_storage(enum storage::type type, std::string name, std::uint64_t id,
-                  ADM_adhoc_context_t ctx);
-    adhoc_storage(enum storage::type type, std::string name, std::uint64_t id,
-                  const admire::adhoc_storage::ctx& ctx);
+    adhoc_storage(enum adhoc_storage::type type, std::string name,
+                  std::uint64_t id, execution_mode exec_mode,
+                  access_type access_type, adhoc_storage::resources res,
+                  std::uint32_t walltime, bool should_flush);
+    explicit adhoc_storage(ADM_adhoc_storage_t storage);
+    adhoc_storage(enum adhoc_storage::type type, std::string name,
+                  std::uint64_t id, const admire::adhoc_storage::ctx& ctx);
 
     adhoc_storage(const adhoc_storage& other) noexcept;
     adhoc_storage(adhoc_storage&&) noexcept;
@@ -414,10 +384,16 @@ struct adhoc_storage : public storage {
     operator=(const adhoc_storage&) noexcept;
     adhoc_storage&
     operator=(adhoc_storage&&) noexcept;
-    ~adhoc_storage() override;
+    ~adhoc_storage();
 
-    std::shared_ptr<storage::ctx>
-    context() const final;
+    std::string
+    name() const;
+    type
+    type() const;
+    std::uint64_t
+    id() const;
+    adhoc_storage::ctx
+    context() const;
 
     void
     update(admire::adhoc_storage::ctx new_ctx);
@@ -427,9 +403,14 @@ private:
     std::unique_ptr<impl> m_pimpl;
 };
 
-struct pfs_storage : public storage {
+struct pfs_storage {
 
-    struct ctx : storage::ctx {
+    enum class type : std::underlying_type<ADM_pfs_storage_type_t>::type {
+        lustre = ADM_PFS_STORAGE_LUSTRE,
+        gpfs = ADM_PFS_STORAGE_GPFS
+    };
+
+    struct ctx {
 
         explicit ctx(std::filesystem::path mount_point);
 
@@ -442,20 +423,24 @@ struct pfs_storage : public storage {
         std::filesystem::path m_mount_point;
     };
 
-    pfs_storage(enum storage::type type, std::string name, std::uint64_t id,
+    pfs_storage(enum pfs_storage::type type, std::string name, std::uint64_t id,
                 std::filesystem::path mount_point);
-    pfs_storage(enum storage::type type, std::string name, std::uint64_t id,
-                ADM_pfs_context_t ctx);
     pfs_storage(const pfs_storage& other) noexcept;
     pfs_storage(pfs_storage&&) noexcept = default;
     pfs_storage&
     operator=(const pfs_storage& other) noexcept;
     pfs_storage&
     operator=(pfs_storage&&) noexcept = default;
-    ~pfs_storage() override;
+    ~pfs_storage();
 
-    std::shared_ptr<storage::ctx>
-    context() const final;
+    std::string
+    name() const;
+    type
+    type() const;
+    std::uint64_t
+    id() const;
+    pfs_storage::ctx
+    context() const;
 
 private:
     class impl;
@@ -547,34 +532,29 @@ struct fmt::formatter<admire::node> : formatter<std::string_view> {
 };
 
 template <>
-struct fmt::formatter<enum admire::storage::type>
+struct fmt::formatter<enum admire::adhoc_storage::type>
     : formatter<std::string_view> {
     // parse is inherited from formatter<string_view>.
     template <typename FormatContext>
     auto
-    format(const enum admire::storage::type& t, FormatContext& ctx) const {
+    format(const enum admire::adhoc_storage::type& t,
+           FormatContext& ctx) const {
 
-        using admire::storage;
+        using admire::adhoc_storage;
         std::string_view name = "unknown";
 
         switch(t) {
-            case storage::type::gekkofs:
-                name = "ADM_STORAGE_GEKKOFS";
-                break;
-            case storage::type::dataclay:
-                name = "ADM_STORAGE_DATACLAY";
+            case adhoc_storage::type::gekkofs:
+                name = "ADM_ADHOC_STORAGE_GEKKOFS";
                 break;
-            case storage::type::expand:
-                name = "ADM_STORAGE_EXPAND";
+            case adhoc_storage::type::dataclay:
+                name = "ADM_ADHOC_STORAGE_DATACLAY";
                 break;
-            case storage::type::hercules:
-                name = "ADM_STORAGE_HERCULES";
+            case adhoc_storage::type::expand:
+                name = "ADM_ADHOC_STORAGE_EXPAND";
                 break;
-            case storage::type::lustre:
-                name = "ADM_STORAGE_LUSTRE";
-                break;
-            case storage::type::gpfs:
-                name = "ADM_STORAGE_GPFS";
+            case adhoc_storage::type::hercules:
+                name = "ADM_ADHOC_STORAGE_HERCULES";
                 break;
         }
 
@@ -643,41 +623,6 @@ struct fmt::formatter<admire::adhoc_storage::access_type>
     }
 };
 
-template <>
-struct fmt::formatter<std::shared_ptr<admire::storage>>
-    : formatter<std::string_view> {
-    // parse is inherited from formatter<string_view>.
-    template <typename FormatContext>
-    auto
-    format(const std::shared_ptr<admire::storage>& s,
-           FormatContext& ctx) const {
-
-        if(!s) {
-            return formatter<std::string_view>::format("NULL", ctx);
-        }
-
-        switch(s->type()) {
-            case admire::storage::type::gekkofs:
-            case admire::storage::type::dataclay:
-            case admire::storage::type::expand:
-            case admire::storage::type::hercules:
-                return formatter<std::string_view>::format(
-                        fmt::format("{}",
-                                    *(dynamic_cast<admire::adhoc_storage*>(
-                                            s.get()))),
-                        ctx);
-            case admire::storage::type::lustre:
-            case admire::storage::type::gpfs:
-                return formatter<std::string_view>::format(
-                        fmt::format("{}", *(dynamic_cast<admire::pfs_storage*>(
-                                                  s.get()))),
-                        ctx);
-            default:
-                return formatter<std::string_view>::format("unknown", ctx);
-        }
-    }
-};
-
 template <typename T>
 struct fmt::formatter<std::optional<T>> : formatter<std::string_view> {
 
@@ -696,14 +641,9 @@ struct fmt::formatter<admire::adhoc_storage> : formatter<std::string_view> {
     template <typename FormatContext>
     auto
     format(const admire::adhoc_storage& s, FormatContext& ctx) const {
-
-        const auto pctx = std::dynamic_pointer_cast<admire::adhoc_storage::ctx>(
-                s.context());
-
-        const auto str =
-                fmt::format("{{type: {}, id: {}, name: {}, context: {}}}",
-                            s.type(), s.id(), std::quoted(s.name()),
-                            (pctx ? fmt::format("{}", *pctx) : "NULL"));
+        const auto str = fmt::format(
+                "{{type: {}, id: {}, name: {}, context: {}}}", s.type(), s.id(),
+                std::quoted(s.name()), s.context());
         return formatter<std::string_view>::format(str, ctx);
     }
 };
@@ -742,6 +682,29 @@ struct fmt::formatter<admire::adhoc_storage::ctx>
     }
 };
 
+template <>
+struct fmt::formatter<enum admire::pfs_storage::type>
+    : formatter<std::string_view> {
+    // parse is inherited from formatter<string_view>.
+    template <typename FormatContext>
+    auto
+    format(const enum admire::pfs_storage::type& t, FormatContext& ctx) const {
+
+        using admire::pfs_storage;
+        std::string_view name = "unknown";
+
+        switch(t) {
+            case pfs_storage::type::lustre:
+                name = "ADM_PFS_STORAGE_LUSTRE";
+                break;
+            case pfs_storage::type::gpfs:
+                name = "ADM_PFS_STORAGE_GPFS";
+                break;
+        }
+
+        return formatter<std::string_view>::format(name, ctx);
+    }
+};
 
 template <>
 struct fmt::formatter<admire::pfs_storage> : formatter<std::string_view> {
@@ -749,11 +712,7 @@ struct fmt::formatter<admire::pfs_storage> : formatter<std::string_view> {
     template <typename FormatContext>
     auto
     format(const admire::pfs_storage& s, FormatContext& ctx) const {
-
-        const auto pctx = std::dynamic_pointer_cast<admire::pfs_storage::ctx>(
-                s.context());
-        const auto str = fmt::format(
-                "{{context: {}}}", (pctx ? fmt::format("{}", *pctx) : "NULL"));
+        const auto str = fmt::format("{{context: {}}}", s.context());
         return formatter<std::string_view>::format(str, ctx);
     }
 };

src/common/api/convert.cpp

@@ -96,27 +96,25 @@ convert(const adhoc_storage::ctx& ctx) {
             std::move(managed_adhoc_resources)};
 }
 
-managed_ctype<ADM_storage_t>
+managed_ctype<ADM_adhoc_storage_t>
 convert(const std::optional<admire::adhoc_storage>& adhoc_storage) {
 
     if(!adhoc_storage) {
-        return managed_ctype<ADM_storage_t>{};
+        return managed_ctype<ADM_adhoc_storage_t>{};
     }
 
     return convert(adhoc_storage.value());
 }
 
-managed_ctype<ADM_storage_t>
+managed_ctype<ADM_adhoc_storage_t>
 convert(const admire::adhoc_storage& st) {
 
-    auto managed_ctx =
-            convert(*std::static_pointer_cast<admire::adhoc_storage::ctx>(
-                    st.context()));
-    ADM_storage_t c_st = ADM_storage_create(
-            st.name().c_str(), static_cast<ADM_storage_type_t>(st.type()),
+    auto managed_ctx = convert(st.context());
+    ADM_adhoc_storage_t c_st = ADM_adhoc_storage_create(
+            st.name().c_str(), static_cast<ADM_adhoc_storage_type_t>(st.type()),
             st.id(), managed_ctx.get());
 
-    return managed_ctype<ADM_storage_t>{c_st, std::move(managed_ctx)};
+    return managed_ctype<ADM_adhoc_storage_t>{c_st, std::move(managed_ctx)};
 }
 
 managed_ctype<ADM_dataset_t>

src/common/api/convert.hpp

@@ -48,7 +48,7 @@ convert(const adhoc_storage::resources& res);
 managed_ctype<ADM_adhoc_context_t>
 convert(const adhoc_storage::ctx& ctx);
 
-managed_ctype<ADM_storage_t>
+managed_ctype<ADM_adhoc_storage_t>
 convert(const admire::adhoc_storage& st);
 
 managed_ctype<ADM_dataset_t>
@@ -200,26 +200,27 @@ struct admire::api::managed_ctype<ADM_adhoc_context_t> {
 };
 
 template <>
-struct admire::api::managed_ctype<ADM_storage_t> {
+struct admire::api::managed_ctype<ADM_adhoc_storage_t> {
 
     managed_ctype() = default;
 
-    explicit managed_ctype(ADM_storage_t st,
+    explicit managed_ctype(ADM_adhoc_storage_t st,
                            managed_ctype<ADM_adhoc_context_t>&& ctx)
         : m_storage(st), m_ctx(std::move(ctx)) {}
 
-    ADM_storage_t
+    ADM_adhoc_storage_t
     get() const {
         return m_storage.get();
     }
 
-    ADM_storage_t
+    ADM_adhoc_storage_t
     release() {
         std::ignore = m_ctx.release();
         return m_storage.release();
     }
 
-    scord::utils::ctype_ptr<ADM_storage_t, ADM_storage_destroy> m_storage;
+    scord::utils::ctype_ptr<ADM_adhoc_storage_t, ADM_adhoc_storage_destroy>
+            m_storage;
     managed_ctype<ADM_adhoc_context_t> m_ctx;
 };
 
@@ -321,9 +322,10 @@ struct admire::api::managed_ctype<ADM_job_requirements_t> {
     explicit managed_ctype(ADM_job_requirements_t reqs,
                            managed_ctype_array<ADM_dataset_t>&& inputs,
                            managed_ctype_array<ADM_dataset_t>&& outputs,
-                           managed_ctype<ADM_storage_t>&& storage)
+                           managed_ctype<ADM_adhoc_storage_t>&& adhoc_storage)
         : m_reqs(reqs), m_inputs(std::move(inputs)),
-          m_outputs(std::move(outputs)), m_storage(std::move(storage)) {}
+          m_outputs(std::move(outputs)),
+          m_adhoc_storage(std::move(adhoc_storage)) {}
 
     ADM_job_requirements_t
     get() const {
@@ -341,7 +343,7 @@ struct admire::api::managed_ctype<ADM_job_requirements_t> {
             m_reqs;
     managed_ctype_array<ADM_dataset_t> m_inputs;
     managed_ctype_array<ADM_dataset_t> m_outputs;
-    managed_ctype<ADM_storage_t> m_storage;
+    managed_ctype<ADM_adhoc_storage_t> m_adhoc_storage;
 };