Merge branch 'hotfix/1.26.3'

ecmwf · Jun 7, 2024 · eeacdc8 · eeacdc8
2 parents c28f641 + c2d6450
commit eeacdc8
Show file tree

Hide file tree

Showing 23 changed files with 487 additions and 92 deletions.
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -211,6 +211,7 @@ ecbuild_add_option( FEATURE JEMALLOC
 #### CUDA
 
 ecbuild_add_option( FEATURE CUDA
+                    DEFAULT OFF
                     CONDITION HAVE_EXPERIMENTAL
                     DESCRIPTION "CUDA GPU linear algebra operations"
                     REQUIRED_PACKAGES CUDA )

diff --git a/README.md b/README.md
@@ -85,6 +85,3 @@ make install
 # 4. Check installation
 $installdir/bin/eckit-version
 ```
-
-
-
diff --git a/VERSION b/VERSION
@@ -1 +1 @@
-1.26.2
+1.26.3
diff --git a/src/eckit/config/Configuration.cc b/src/eckit/config/Configuration.cc
@@ -73,6 +73,10 @@ eckit::Value Configuration::lookUp(const std::string& s, bool& found) const {
     eckit::Value result = *root_;
 
     for (size_t i = 0; i < path.size(); i++) {
+        if (!(result.isMap() || result.isOrderedMap())) {
+            found = false;
+            return result;
+        }
         const std::string& key = path[i];
         if (!result.contains(key)) {
             found = false;
@@ -460,6 +464,107 @@ LocalConfiguration Configuration::getSubConfiguration(const std::string& name) c
     return result;
 }
 
+bool Configuration::isIntegral(const std::string& name) const {
+    bool found = false;
+    eckit::Value v = lookUp(name, found);
+    return found && v.isNumber();
+}
+
+bool Configuration::isBoolean(const std::string& name) const {
+    bool found = false;
+    eckit::Value v = lookUp(name, found);
+    return found && v.isBool();
+}
+
+bool Configuration::isFloatingPoint(const std::string& name) const {
+    bool found = false;
+    eckit::Value v = lookUp(name, found);
+    return found && v.isDouble();
+}
+
+bool Configuration::isString(const std::string& name) const {
+    bool found = false;
+    eckit::Value v = lookUp(name, found);
+    return found && v.isString();
+}
+
+bool Configuration::isList(const std::string& name) const {
+    bool found = false;
+    eckit::Value v = lookUp(name, found);
+    return found && v.isList();
+}
+
+bool Configuration::isSubConfiguration(const std::string& name) const {
+    bool found     = false;
+    eckit::Value v = lookUp(name, found);
+    return found && (v.isMap() || v.isOrderedMap());
+}
+
+bool Configuration::isIntegralList(const std::string& name) const {
+    bool found = false;
+    eckit::Value v = lookUp(name, found);
+    if (found && v.isList()) {
+        if (v.size() == 0) {
+            return true;
+        }
+        auto& firstElement = v[0];
+        return firstElement.isNumber();
+    }
+    return false;
+}
+
+bool Configuration::isBooleanList(const std::string& name) const {
+    bool found = false;
+    eckit::Value v = lookUp(name, found);
+    if (found && v.isList()) {
+        if (v.size() == 0) {
+            return true;
+        }
+        auto& firstElement = v[0];
+        return firstElement.isBool();
+    }
+    return false;
+}
+
+bool Configuration::isFloatingPointList(const std::string& name) const {
+    bool found = false;
+    eckit::Value v = lookUp(name, found);
+    if (found && v.isList()) {
+        if (v.size() == 0) {
+            return true;
+        }
+        auto& firstElement = v[0];
+        return firstElement.isDouble();
+    }
+    return false;
+}
+
+bool Configuration::isStringList(const std::string& name) const {
+    bool found = false;
+    eckit::Value v = lookUp(name, found);
+    if (found && v.isList()) {
+        if (v.size() == 0) {
+            return true;
+        }
+        auto& firstElement = v[0];
+        return firstElement.isString();
+    }
+    return false;
+}
+
+bool Configuration::isSubConfigurationList(const std::string& name) const {
+    bool found = false;
+    eckit::Value v = lookUp(name, found);
+    if (found && v.isList()) {
+        if (v.size() == 0) {
+            return true;
+        }
+        auto& firstElement = v[0];
+        return firstElement.isMap() || firstElement.isOrderedMap();
+    }
+    return false;
+}
+
 template <class T>
 void Configuration::_getWithDefault(const std::string& name, T& value, const T& defaultVal) const {
     if (!get(name, value)) {

diff --git a/src/eckit/config/Configuration.h b/src/eckit/config/Configuration.h
@@ -18,6 +18,7 @@
 
 #include <cstdint>
 #include <memory>
+#include <type_traits>
 #include "eckit/config/Parametrisation.h"
 
 
@@ -133,6 +134,70 @@ class Configuration : public Parametrisation {
 
     virtual void hash(eckit::Hash&) const;
 
+    // -- Introspection methods
+
+    bool isSubConfiguration(const std::string& name) const;
+
+    bool isIntegral(const std::string& name) const;
+
+    bool isBoolean(const std::string& name) const;
+
+    bool isFloatingPoint(const std::string& name) const;
+
+    bool isString(const std::string& name) const;
+
+    bool isList(const std::string& name) const;
+
+    bool isSubConfigurationList(const std::string& name) const;
+
+    bool isIntegralList(const std::string& name) const;
+
+    bool isBooleanList(const std::string& name) const;
+
+    bool isFloatingPointList(const std::string& name) const;
+
+    bool isStringList(const std::string& name) const;
+
+    template <typename T>
+    bool isConvertible(const std::string& name) const {
+        using _T = std::decay_t<T>;
+        if constexpr(std::is_base_of_v<LocalConfiguration,_T>) {
+            return isSubConfiguration(name);
+        }
+        else if constexpr(std::is_same_v<_T,int> || std::is_same_v<_T,long> || std::is_same_v<_T,long long> || std::is_same_v<_T,std::size_t>) {
+            return isIntegral(name) || isBoolean(name);
+        }
+        else if constexpr(std::is_same_v<_T,float> || std::is_same_v<_T,double>) {
+            return isFloatingPoint(name) || isIntegral(name) || isBoolean(name);
+        }
+        else if constexpr(std::is_same_v<_T,std::string>) {
+            return isString(name);
+        }
+        else if constexpr(is_vector<_T>::value) {
+            using _V = std::decay_t<typename _T::value_type>;
+            if constexpr(std::is_base_of_v<LocalConfiguration,_V>) {
+                return isSubConfigurationList(name);
+            }
+            else if constexpr(std::is_same_v<_V,int> || std::is_same_v<_V,long> || std::is_same_v<_V,long long> || std::is_same_v<_V,std::size_t>) {
+                return isIntegralList(name) || isBooleanList(name);
+            }
+            else if constexpr(std::is_same_v<_V,float> || std::is_same_v<_V,double>) {
+                return isFloatingPointList(name) || isIntegralList(name) || isBooleanList(name);
+            }
+            else if constexpr(std::is_same_v<_V,std::string>) {
+                return isStringList(name);
+            }
+        }
+        else {
+            return false;
+        }
+    }
+
+    template <typename T>
+    bool isConvertible(const std::string& name, T&) const {
+        return isConvertible<T>(name);
+    }
+
 protected:  // methods
     Configuration(const eckit::Value&, char separator = '.');
 
@@ -173,6 +238,21 @@ class Configuration : public Parametrisation {
         p.print(s);
         return s;
     }
+
+private:
+
+    // Helper structs for introspection of template T in isConvertible<T> method
+    template<class T>
+    struct is_vector {
+        using type = T ;
+        constexpr static bool value = false;
+    };
+
+    template<class T>
+    struct is_vector<std::vector<T>> {
+        using type = std::vector<T> ;
+        constexpr static bool value = true;
+    };
 };
 
 //----------------------------------------------------------------------------------------------------------------------

diff --git a/src/eckit/filesystem/URI.h b/src/eckit/filesystem/URI.h
@@ -43,7 +43,7 @@ class URI {
 
     // Contructors
     URI();
-    URI(const std::string& uri);
+    explicit URI(const std::string& uri);
     URI(const std::string& scheme, const PathName& path);
     URI(const std::string& scheme, const URI& uri);
     URI(const std::string& scheme, const std::string& hostname, int port);

diff --git a/src/eckit/io/MultiHandle.cc b/src/eckit/io/MultiHandle.cc
@@ -149,11 +149,13 @@ long MultiHandle::read1(char* buffer, long length) {
     }
 
     long n = (*current_)->read(buffer, length);
-    if (n <= 0) {
+    if (n < length) {
         (*current_)->close();
         current_++;
         openCurrent();
-        return read1(buffer, length);
+        if (n <= 0) {
+            return read1(buffer, length);
+        }
     }
     return n;
 }

diff --git a/src/eckit/log/SysLog.cc b/src/eckit/log/SysLog.cc
@@ -18,6 +18,7 @@
 #include "eckit/runtime/Main.h"
 
 #include "eckit/log/TimeStamp.h"
+#include "eckit/net/IPAddress.h"
 
 namespace eckit {
 
@@ -43,11 +44,26 @@ int SysLog::procid() const {
     return ::getpid();
 }
 
+
 std::string SysLog::structuredData() const {
+    if (software_.empty() && swVersion_.empty() && enterpriseId_.empty()) {
+        return std::string(1, nilvalue());
+    }
+    // RFC 5424 section 6.3 (only origin)
     std::ostringstream s;
-
-    /// @todo Implement the structured message meta-description as described in RFC5424 secion 6.3
-    s << nilvalue();
+    std::string ip = net::IPAddress::myIPAddress().asString();
+
+    s << "[origin ip=\"" << ip << "\"";
+    if (!enterpriseId_.empty()) {
+        s << " enterpriseId=\"" << enterpriseId_ << "\"";
+    }
+    if (!software_.empty()) {
+        s << " software=\"" << software_ << "\"";
+        if (!swVersion_.empty()) {
+            s << " swVersion=\"" << swVersion_ << "\"";
+        }
+    }
+    s << "]";
 
     return s.str();
 }
@@ -59,7 +75,7 @@ SysLog::operator std::string() const {
     static char sep = ' ';
 
     os  // RFC 5424 section 6.2 (Header)
-        << "<" << priotity() << ">" << version() << sep << timestamp() << sep << fqdn() << sep << appName() << sep
+        << "<" << priority() << ">" << version() << sep << timestamp() << sep << fqdn() << sep << appName() << sep
         << procid() << sep << msgid()
         << sep
         // RFC 5424 section 6.3

diff --git a/src/eckit/log/SysLog.h b/src/eckit/log/SysLog.h
@@ -72,7 +72,7 @@ class SysLog {
 
     SysLog(const std::string& msg, int msgid = 0, Facility f = SysLog::User, Severity s = SysLog::Info);
 
-    unsigned priotity() const { return facility_ * 8 + severity_; }
+    unsigned priority() const { return facility_ * 8 + severity_; }
 
     unsigned version() const { return 1; }
 
@@ -99,6 +99,11 @@ class SysLog {
         return s;
     }
 
+    /// Optional fields for structured data (RFC 5424 section 6.3)
+    void software(const std::string& software) { software_ = software; }
+    void swVersion(const std::string& version) { swVersion_ = version; }
+    void enterpriseId(const std::string& id) { enterpriseId_ = id; }
+
 private:  // methods
     void print(std::ostream& out) const;
 
@@ -112,6 +117,11 @@ class SysLog {
     int msgid_;
 
     std::string msg_;
+
+    // optional fields for structured data
+    std::string software_;
+    std::string swVersion_;
+    std::string enterpriseId_;
 };
 
 }  // namespace eckit

diff --git a/src/eckit/log/TimeStamp.cc b/src/eckit/log/TimeStamp.cc
@@ -9,6 +9,8 @@
  */
 
 #include <sstream>
+#include <iomanip>
+#include <cstdint>
 
 #include "eckit/eckit.h"
 
@@ -27,6 +29,12 @@ TimeStamp::TimeStamp(time_t t, const std::string& format) :
     time_(t), format_(format) {}
 
 std::ostream& operator<<(std::ostream& s, const TimeStamp& x) {
+
+    if (x.format_ == "hex") {
+        s << std::setw(16) << std::setfill('0') << std::hex << static_cast<std::uint64_t>(x.time_);
+        return s;
+    }
+
     char buf[80];
 #if eckit_HAVE_GMTIME_R
     struct tm t;