request.h

Go to the documentation of this file.

#ifndef ZYPP_NG_MEDIA_CURL_REQUEST_H_INCLUDED
#define ZYPP_NG_MEDIA_CURL_REQUEST_H_INCLUDED
 
#include <zypp-curl/ng/network/networkrequesterror.h>
#include <zypp-curl/ng/network/TransferSettings>
#include <zypp-core/zyppng/base/Base>
#include <zypp-core/zyppng/core/Url>
#include <zypp-core/zyppng/core/ByteArray>
#include <zypp-core/zyppng/base/zyppglobal.h>
#include <zypp-core/zyppng/base/signals.h>
#include <zypp-core/base/Flags.h>
#include <zypp-core/ByteCount.h>
#include <optional>
#include <vector>
#include <chrono>
#include <any>
 
namespace zypp {
  class Digest;
 
  namespace media {
    class AuthData;
  }
}
 
namespace zyppng {
 
  using AuthData = zypp::media::AuthData;
 
  class NetworkRequestDispatcher;
  class NetworkRequestPrivate;
 
  class LIBZYPP_NG_EXPORT NetworkRequest : public Base
  {
  public:
 
    using Ptr = std::shared_ptr<NetworkRequest>;
    using WeakPtr = std::weak_ptr<NetworkRequest>;
    using DigestPtr = std::shared_ptr<zypp::Digest>;
    using CheckSumBytes = UByteArray;
 
    enum State {
      Pending,    //< waiting to be dispatched
      Running,    //< currently running
      Finished,   //< finished successfully
      Error,      //< Error, use error function to figure out the issue
    };
 
    enum Priority {
      Normal,         //< Requests with normal priority will be enqueued as they come in
      High,           //< Request with high priority will be moved to the front of the queue
      Critical = 100, //< Those requests will be enqueued as fast as possible, even before High priority requests, this should be used only if requests needs to start immediately
    };
 
    enum FileMode {
      WriteExclusive, //< the request will create its own file, overwriting anything that already exists
      WriteShared     //< the request will create or open the file in shared mode and only write between \a start and \a len
    };
 
    enum OptionBits {
      Default        = 0x00, //< no special options, just do a normal download
      HeadRequest    = 0x01, //< only request the header part of the file
      ConnectionTest = 0x02  //< only connect to collect connection speed information
    };
    ZYPP_DECLARE_FLAGS(Options, OptionBits);
 
    struct Range {
      size_t start = 0;
      size_t len = 0;
      size_t bytesWritten = 0;
      DigestPtr _digest; //< zypp::Digest that is updated when data is written, can be used to validate the file contents with a checksum
 
      CheckSumBytes _checksum;
      std::optional<size_t> _relevantDigestLen; //< If this is initialized , it defines how many bytes of the resulting checkum are compared
      std::optional<size_t> _chksumPad;   //< If initialized we need to pad the digest with zeros before calculating the final checksum
      std::any userData; //< Custom data the user can associate with the Range
 
      State _rangeState = State::Pending; //< Flag to know if this range has been already requested and if the request was successful
 
      static Range make ( size_t start, size_t len = 0, DigestPtr &&digest = nullptr, CheckSumBytes &&expectedChkSum = CheckSumBytes(), std::any &&userData = std::any(), std::optional<size_t> digestCompareLen = {}, std::optional<size_t> _dataBlockPadding = {} );
    };
 
    struct Timings {
      std::chrono::microseconds namelookup;
      std::chrono::microseconds connect;
      std::chrono::microseconds appconnect;
      std::chrono::microseconds pretransfer;
      std::chrono::microseconds total;
      std::chrono::microseconds redirect;
    };
 
    NetworkRequest(Url url, zypp::Pathname targetFile, FileMode fMode = WriteExclusive );
    virtual ~NetworkRequest();
 
    void setExpectedFileSize ( zypp::ByteCount expectedFileSize );
 
    void setPriority ( Priority prio, bool triggerReschedule = true );
 
    Priority priority ( ) const;
 
    void setOptions ( Options opt );
 
    Options options () const;
 
    void addRequestRange ( size_t start, size_t len = 0, DigestPtr digest = nullptr, CheckSumBytes expectedChkSum = CheckSumBytes(), std::any userData = std::any(), std::optional<size_t> digestCompareLen = {}, std::optional<size_t> chksumpad = {}  );
 
    void addRequestRange ( const Range &range );
 
    void resetRequestRanges ( );
 
    std::vector<Range> failedRanges () const;
    const std::vector<Range> &requestedRanges () const;
 
    const std::string &lastRedirectInfo() const;
 
    void *nativeHandle () const;
 
    std::optional<Timings> timings () const;
 
    std::vector<char> peekData ( off_t offset, size_t count ) const;
 
    Url url () const;
 
    void setUrl ( const Url & url );
 
    const zypp::Pathname & targetFilePath () const;
 
    void setTargetFilePath ( const zypp::Pathname &path );
 
    FileMode fileOpenMode () const;
 
    void setFileOpenMode ( FileMode mode );
 
    std::string contentType () const;
 
    zypp::ByteCount reportedByteCount() const;
 
    zypp::ByteCount downloadedByteCount() const;
 
    TransferSettings &transferSettings ();
 
    State state () const;
 
    NetworkRequestError error () const;
 
    std::string extendedErrorString() const;
 
    bool hasError () const;
 
    bool addRequestHeader(const std::string &header );
 
    SignalProxy<void ( NetworkRequest &req )> sigStarted  ();
 
    SignalProxy<void ( NetworkRequest &req, zypp::ByteCount count )> sigBytesDownloaded ();
 
    SignalProxy<void ( NetworkRequest &req, off_t dltotal, off_t dlnow, off_t ultotal, off_t ulnow )> sigProgress ();
 
    SignalProxy<void ( NetworkRequest &req, const NetworkRequestError &err)> sigFinished ( );
 
  private:
    friend class NetworkRequestDispatcher;
    friend class NetworkRequestDispatcherPrivate;
    ZYPP_DECLARE_PRIVATE( NetworkRequest )
  };
 
}
ZYPP_DECLARE_OPERATORS_FOR_FLAGS(zyppng::NetworkRequest::Options);
 
#endif