metkitlib 1.16.0.9__cp312-cp312-manylinux_2_28_aarch64.whl

metkitlib/include/metkit/mars/ClientTask.h

@@ -0,0 +1,206 @@
+/*
+ * (C) Copyright 1996- ECMWF.
+ *
+ * This software is licensed under the terms of the Apache Licence Version 2.0
+ * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
+ * In applying this licence, ECMWF does not waive the privileges and immunities
+ * granted to it by virtue of its status as an intergovernmental organisation nor
+ * does it submit to any jurisdiction.
+ */
+
+// File ClientTask.h
+// Baudouin Raoult - ECMWF Oct 96
+
+#ifndef metkit_ClientTask_H
+#define metkit_ClientTask_H
+
+#include <memory>
+
+// #include "eckit/bases/Watcher.h"
+#include "eckit/exception/Exceptions.h"
+#include "eckit/io/DataHandle.h"
+// #include "eckit/log/UserChannel.h"
+#include "eckit/transaction/TxnEvent.h"
+
+#include "metkit/mars/MarsRequest.h"
+
+namespace metkit {
+namespace mars {
+
+class ClientTask {
+public:
+
+
+    // -- Contructors
+
+    ClientTask(const MarsRequest&, const MarsRequest&, const std::string& name, int port, unsigned long long id = 0);
+
+    // ClientTask(eckit::Stream&);
+
+    // -- Destructor
+
+    ~ClientTask();
+
+    // -- Convertors
+    // None
+
+    // -- Operators
+    // None
+
+    // -- Methods
+
+    // void dump(std::ostream&) const;
+    // void json(eckit::JSON&) const;
+
+    // MarsInfo info() const;
+    // const MarsID&  id() const { return transactionID();  }
+    // const MarsRequest& request()   const { return request_; }
+    // const MarsRequest& environ()   const { return environ_; }
+
+    // eckit::Length transferData(const eckit::PathName&);
+    // eckit::PathName transferData();
+
+    //    /// @returns eckit::DataHandle with the data that will be received, but does not give ownership of the
+    //    eckit::DataHandle eckit::DataHandle& getDataHandle();
+
+    // void sendData(eckit::DataHandle&);
+    // void sendHandle(eckit::DataHandle&);
+
+    // void acknowledge(eckit::Stream& s)     { send(s,'a'); }
+    // void patch();
+    //    bool authenticated() const;
+
+    // eckit::DataHandle& dataHandle() { return *handle_; }
+
+    // // Report
+
+    // void success();
+    // void failure(const std::string&);
+    // void retry(const std::string&);
+
+    // void infoMsg(const std::string&);
+    // void warningMsg(const std::string&);
+    // void errorMsg(const std::string&);
+    // void notifyClient(const std::string&);
+    // void notifyStart();
+
+    // void   queueTime();
+
+    // void ping();
+    // void sendCost();
+
+    // void sendChecksum(const std::string&);
+
+    // // Queuing
+
+    // double startingPriority()  const  { return startingPriority_;}
+    // void   startingPriority(double p) { startingPriority_ = p;}
+
+    // // Cost
+
+    // Cost& cost()             { return cost_; }
+    // const Cost& cost() const { return cost_; }
+    // void  costChanged();
+
+
+    //    // Called by PipeProcess
+
+    //    void           send(eckit::Stream&);
+    //    void           reply(eckit::Stream&);
+    // bool           error(std::exception&,int);
+    // void           done();
+
+    // Logging
+
+
+    // Mars tree
+
+    // void push(const std::string&,const std::string&);
+    // void pop();
+    // void reset();
+
+    // const eckit::StringList& treeNames() const { return treeNames_; }
+    // const eckit::StringList& treeValues() const { return treeValues_; }
+
+    //    // For the metkit
+    void send(eckit::Stream&) const;
+    char receive(eckit::Stream&) const;
+
+
+    // -- Overridden methods
+
+    // From Streamble
+
+    // virtual void encode(eckit::Stream&) const override;
+    // virtual const eckit::ReanimatorBase& reanimator() const { return reanimator_; }
+
+    // From watcher
+
+    // virtual void watch();
+
+    // -- Class methods
+
+    // static const eckit::ClassSpec&  classSpec()        { return classSpec_;}
+    // static void  recover(TxnRecoverer<ClientTask>&);
+    // static void  find(TxnFinder<ClientTask>&);
+    // static std::string commandName();
+
+    // None
+
+protected:
+
+    // -- Members
+
+    MarsRequest request_;
+    MarsRequest environ_;
+
+private:
+
+    // -- Members
+
+    // unsigned long long   txnID_; // unused
+    unsigned long long metkitID_;
+    int port_;
+    std::string host_;
+    std::unique_ptr<eckit::DataHandle> handle_;
+    std::string checksum_;
+
+    // Not sent over streams
+
+    // double               startingPriority_;
+    // Cost                 cost_;
+    // time_t               lastPing_;
+    // time_t               queueTime_;
+
+    // eckit::StringList			treeValues_;
+    // eckit::StringList			treeNames_;
+
+    //    bool                authenticated_;
+
+    // -- Methods
+
+    // void print(std::ostream&) const;
+    // void send(eckit::Stream&,char) const;
+
+    // -- Overridden methods
+    // None
+
+    // -- Class members
+
+    // static eckit::ClassSpec               classSpec_;
+    // static eckit::Reanimator<ClientTask>    reanimator_;
+
+    // -- Class methods
+    // None
+
+    // friend std::ostream& operator<<(std::ostream& s, const ClientTask& r)
+    //     { r.print(s); return s; }
+
+    // friend eckit::JSON& operator<<(eckit::JSON& s, const ClientTask& r)
+    //     { r.json(s); return s; }
+};
+
+}  // namespace mars
+}  // namespace metkit
+
+#endif

metkitlib/include/metkit/mars/DHSProtocol.h

@@ -0,0 +1,106 @@
+/*
+ * (C) Copyright 1996- ECMWF.
+ *
+ * This software is licensed under the terms of the Apache Licence Version 2.0
+ * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
+ * In applying this licence, ECMWF does not waive the privileges and immunities
+ * granted to it by virtue of its status as an intergovernmental organisation nor
+ * does it submit to any jurisdiction.
+ */
+
+// File DHSProtocol.h
+// Baudouin Raoult - (c) ECMWF Feb 12
+
+#ifndef DHSProtocol_H
+#define DHSProtocol_H
+
+#include <memory>
+
+#include "eckit/net/Endpoint.h"
+#include "eckit/net/TCPServer.h"
+#include "eckit/net/TCPSocket.h"
+
+#include "metkit/mars/BaseProtocol.h"
+#include "metkit/mars/ClientTask.h"
+#include "metkit/mars/MarsRequest.h"
+
+
+namespace metkit {
+namespace mars {
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+class BaseCallbackConnection : public eckit::Streamable {
+public:
+
+    BaseCallbackConnection() {}
+    virtual ~BaseCallbackConnection() {}
+
+    static BaseCallbackConnection* build(const eckit::Configuration& config, const std::string& host = "");
+
+    virtual const eckit::net::Endpoint& endpoint() const = 0;
+
+    virtual eckit::net::TCPSocket& connect() = 0;
+
+    virtual void encode(eckit::Stream&) const override = 0;
+    static const eckit::ClassSpec& classSpec();
+};
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+
+class DHSProtocol : public BaseProtocol {
+
+public:
+
+    DHSProtocol(const eckit::Configuration&);
+
+    DHSProtocol(const eckit::Configuration&, const std::map<std::string, std::string>& env);
+
+    DHSProtocol(const std::string& name, const std::string& host, int port, bool forewardMessages = false);
+
+    DHSProtocol(eckit::Stream&);
+    ~DHSProtocol();
+
+    // -- Overridden methods (from Streamable)
+
+    virtual std::string className() const override { return "DHSProtocol"; }
+    virtual const eckit::ReanimatorBase& reanimator() const override;
+    static const eckit::ClassSpec& classSpec();
+
+private:
+
+    // -- Members
+    std::unique_ptr<BaseCallbackConnection> callback_;
+    eckit::net::TCPSocket socket_;
+    std::string name_;
+    std::string host_;
+    int port_;
+    std::string msg_;
+    std::unique_ptr<ClientTask> task_;
+    bool done_;
+    bool error_;
+    bool sending_;
+    bool forward_;
+    MarsRequest env_;
+
+    // -- Methods
+    bool wait(eckit::Length&);
+
+    // -- Overridden methods
+    // From BaseProtocol
+    virtual eckit::Length retrieve(const MarsRequest& request) override;
+    virtual void archive(const MarsRequest& request, const eckit::Length&) override;
+    virtual long read(void* buffer, long len) override;
+    virtual long write(const void* buffer, long len) override;
+    virtual void cleanup() override;
+    virtual void print(std::ostream&) const override;
+    virtual void encode(eckit::Stream&) const override;
+};
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+}  // namespace mars
+}  // namespace metkit
+
+#endif

metkitlib/include/metkit/mars/MarsExpandContext.h

@@ -0,0 +1,42 @@
+/*
+ * (C) Copyright 1996- ECMWF.
+ *
+ * This software is licensed under the terms of the Apache Licence Version 2.0
+ * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
+ * In applying this licence, ECMWF does not waive the privileges and immunities
+ * granted to it by virtue of its status as an intergovernmental organisation nor
+ * does it submit to any jurisdiction.
+ */
+
+/// @author Manuel Fuentes
+/// @author Baudouin Raoult
+/// @author Tiago Quintino
+
+/// @date Sep 96
+
+#pragma once
+
+#include <iosfwd>
+
+namespace metkit::mars {
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class [[deprecated]] MarsExpandContext {
+
+    void info(std::ostream&) const {}
+
+public:
+
+    friend std::ostream& operator<<(std::ostream& s, const MarsExpandContext& r) { return s; }
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class [[deprecated]] DummyContext : public MarsExpandContext {
+    using MarsExpandContext::MarsExpandContext;
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+
+}  // namespace metkit::mars

metkitlib/include/metkit/mars/MarsExpansion.h

@@ -0,0 +1,83 @@
+/*
+ * (C) Copyright 1996- ECMWF.
+ *
+ * This software is licensed under the terms of the Apache Licence Version 2.0
+ * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
+ * In applying this licence, ECMWF does not waive the privileges and immunities
+ * granted to it by virtue of its status as an intergovernmental organisation nor
+ * does it submit to any jurisdiction.
+ */
+
+/// @author Manuel Fuentes
+/// @author Baudouin Raoult
+/// @author Tiago Quintino
+
+/// @date Sep 96
+
+#ifndef metkit_MarsExpansion_H
+#define metkit_MarsExpansion_H
+
+#include "eckit/memory/NonCopyable.h"
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "metkit/mars/MarsExpandContext.h"
+#include "metkit/mars/MarsParsedRequest.h"
+#include "metkit/mars/MarsRequest.h"
+
+
+namespace metkit::mars {
+
+class MarsLanguage;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class FlattenCallback {
+public:
+
+    virtual ~FlattenCallback();
+    virtual void operator()(const MarsRequest&) = 0;
+};
+
+class ExpandCallback {
+public:
+
+    virtual ~ExpandCallback();
+    virtual void operator()(const MarsRequest& request) { this->operator()(DummyContext{}, request); }
+    virtual void operator()(const MarsExpandContext&, const MarsRequest&) = 0;
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class MarsExpansion : public eckit::NonCopyable {
+public:
+
+    MarsExpansion(bool inherit, bool strict = false);
+    ~MarsExpansion();
+
+    void reset();
+
+    MarsRequest expand(const MarsRequest&);
+    std::vector<MarsRequest> expand(const std::vector<MarsParsedRequest>&);
+
+    void expand(const MarsRequest&, ExpandCallback&);
+    void expand(const MarsExpandContext&, const MarsRequest&, ExpandCallback&);
+    void flatten(const MarsRequest&, FlattenCallback&);
+    void flatten(const MarsExpandContext&, const MarsRequest&, FlattenCallback&);
+
+private:
+
+    MarsLanguage& language(const std::string& verb);
+
+    std::map<std::string, MarsLanguage*> languages_;
+    bool inherit_;
+    bool strict_;
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+
+}  // namespace metkit::mars
+
+#endif

metkitlib/include/metkit/mars/MarsExpension.h

@@ -0,0 +1,28 @@
+/*
+ * (C) Copyright 1996- ECMWF.
+ *
+ * This software is licensed under the terms of the Apache Licence Version 2.0
+ * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
+ * In applying this licence, ECMWF does not waive the privileges and immunities
+ * granted to it by virtue of its status as an intergovernmental organisation nor
+ * does it submit to any jurisdiction.
+ */
+
+#ifndef metkit_MarsExpension_H
+#define metkit_MarsExpension_H
+
+#include "metkit/mars/MarsExpansion.h"
+
+namespace metkit::mars {
+
+//----------------------------------------------------------------------------------------------------------------------
+
+struct [[deprecated("Use MarsExpansion instead")]] MarsExpension : MarsExpansion {
+    using MarsExpansion::MarsExpansion;
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+
+}  // namespace metkit::mars
+
+#endif

metkitlib/include/metkit/mars/MarsHandle.h

@@ -0,0 +1,83 @@
+/*
+ * (C) Copyright 1996- ECMWF.
+ *
+ * This software is licensed under the terms of the Apache Licence Version 2.0
+ * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
+ * In applying this licence, ECMWF does not waive the privileges and immunities
+ * granted to it by virtue of its status as an intergovernmental organisation nor
+ * does it submit to any jurisdiction.
+ */
+
+// File MarsHandle.h
+// Baudouin Raoult - ECMWF Oct 96
+
+#ifndef MarsHandle_H
+#define MarsHandle_H
+
+#include "eckit/io/Length.h"
+#include "eckit/io/TCPHandle.h"
+#include "eckit/serialisation/Stream.h"
+
+class MarsHandle : public eckit::TCPHandle {
+public:
+
+    // -- Contructors
+
+    MarsHandle(const std::string& host, int port, unsigned long long);
+    MarsHandle(eckit::Stream&);
+
+    // -- Destructor
+
+    ~MarsHandle();
+
+    // -- Overridden methods
+
+    // From eckit::DataHandle
+
+    virtual eckit::Length openForRead() override;
+    virtual void openForWrite(const eckit::Length&) override;
+    virtual void openForAppend(const eckit::Length&) override;
+
+    virtual void close() override;
+    virtual long read(void*, long) override;
+    virtual long write(const void*, long) override;
+
+    virtual eckit::Length estimate() override;
+    virtual std::string title() const override;
+    virtual std::string metricsTag() const override;
+
+    virtual bool moveable() const override { return true; }
+
+    // From Streamable
+
+    virtual void encode(eckit::Stream&) const override;
+    virtual const eckit::ReanimatorBase& reanimator() const override { return reanimator_; }
+
+    // -- Class methods
+
+    static const eckit::ClassSpec& classSpec();
+
+private:
+
+    // -- Members
+
+    unsigned long long clientID_;
+    eckit::Length length_;
+    eckit::Length total_;
+    bool receiving_;
+    bool streamMode_;
+    bool doCRC_;
+    unsigned long crc_;
+
+    // -- Methods
+
+    void updateCRC(void*, long);
+
+    // -- Class members
+
+    static eckit::Reanimator<MarsHandle> reanimator_;
+
+    friend class MarsHandleStream;
+};
+
+#endif

metkitlib/include/metkit/mars/MarsLanguage.h

@@ -0,0 +1,106 @@
+/*
+ * (C) Copyright 1996- ECMWF.
+ *
+ * This software is licensed under the terms of the Apache Licence Version 2.0
+ * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
+ * In applying this licence, ECMWF does not waive the privileges and immunities
+ * granted to it by virtue of its status as an intergovernmental organisation nor
+ * does it submit to any jurisdiction.
+ */
+
+/// @author Manuel Fuentes
+/// @author Baudouin Raoult
+/// @author Tiago Quintino
+
+/// @date Sep 96
+
+#pragma once
+
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "eckit/memory/NonCopyable.h"
+
+#include "metkit/mars/MarsRequest.h"
+
+
+namespace metkit::mars {
+
+class Context;
+class FlattenCallback;
+class Type;
+
+//----------------------------------------------------------------------------------------------------------------------
+
+enum class ModifierType {
+    DEFAULT,
+    SET,
+    UNSET
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+
+class MarsLanguage : private eckit::NonCopyable {
+
+public:  // methods
+
+    MarsLanguage(const std::string& verb);
+
+    ~MarsLanguage();
+
+    MarsRequest expand(const MarsRequest& r, bool inherit, bool strict);
+
+    void reset();
+
+    const std::string& verb() const;
+
+    void flatten(const MarsRequest& request, FlattenCallback& callback);
+
+    static eckit::PathName languageYamlFile();
+
+    Type* type(const std::string& name) const;
+
+    bool isData(const std::string& keyword) const;
+
+    bool isPostProc(const std::string& keyword) const;
+
+    bool isSink(const std::string& keyword) const;
+    const std::set<std::string>& sinkKeywords() const;
+
+public:  // class methods
+
+    static std::string expandVerb(const std::string& verb);
+
+    static std::string bestMatch(const std::string& name, const std::vector<std::string>& values, bool fail, bool quiet,
+                                 bool fullMatch, const std::map<std::string, std::string>& aliases = {});
+
+    static eckit::Value jsonFile(const std::string& name);
+
+
+private:  // methods
+
+    void flatten(const MarsRequest& request, const std::vector<std::string>& params, size_t i, MarsRequest& result,
+                 FlattenCallback& callback);
+    void parseModifier(ModifierType typ, std::shared_ptr<Context> ctx, size_t maxIndex, const eckit::Value& mod);
+
+private:  // members
+
+    std::string verb_;
+    std::map<std::string, Type*> types_;
+    std::set<std::string> dataKeywords_;
+    std::set<std::string> sinkKeywords_;
+    std::set<std::string> postProcKeywords_;
+    std::vector<std::pair<std::string, Type*>> typesByAxisOrder_;
+    std::vector<std::string> keywords_;
+
+    std::map<std::string, std::string> aliases_;
+
+    mutable std::map<std::string, std::string> cache_;
+};
+
+//----------------------------------------------------------------------------------------------------------------------
+
+}  // namespace metkit::mars