providemessage_p.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\----------------------------------------------------------------------/
*
* This file contains private API, this might break at any time between releases.
* You have been warned!
*/
#ifndef ZYPP_MEDIA_PRIVATE_PROVIDE_MESSAGE_P_H_INCLUDED
#define ZYPP_MEDIA_PRIVATE_PROVIDE_MESSAGE_P_H_INCLUDED
 
#include <zypp-core/rpc/PluginFrame.h>
#include <zypp-core/zyppng/pipelines/expected.h>

 
#include <zypp-core/base/PtrTypes.h>
#include <zypp-core/zyppng/pipelines/Expected>
#include <zypp-core/zyppng/rpc/stompframestream.h>
#include <zypp-media/ng/ProvideSpec> // for FieldType
#include <zypp-media/ng/HeaderValueMap>
 
#include <boost/iterator/iterator_adaptor.hpp>
 
namespace zypp::proto {
  class Envelope;
  class Configuration;
  class Capabilities;
  class ProvideMessage;
}
 
namespace zyppng {
 
  enum MessageCodes : uint32_t {
    NoCode = 0,
    FirstInformalCode = 100,
    ProvideStarted    = 100,
    LastInformalCode  = 199,
 
    FirstSuccessCode  = 200,
    ProvideFinished   = 200,
    AttachFinished    = 201,
    AuthInfo          = 202,
    MediaChanged      = 203,
    DetachFinished    = 204,
    LastSuccessCode   = 299,
 
    FirstRedirCode    = 300,
    Redirect          = 300,
    Metalink          = 301,
    LastRedirCode     = 399,
 
    FirstClientErrCode      = 400,
    BadRequest              = 400,
    Unauthorized            = 401,
    Forbidden               = 402,
    PeerCertificateInvalid  = 403,
    NotFound                = 404,
    ExpectedSizeExceeded    = 405,
    ConnectionFailed        = 406,
    Timeout                 = 407,
    Cancelled               = 408,
    InvalidChecksum         = 409,
    MountFailed             = 410,
    Jammed                  = 411,
    MediaChangeAbort        = 412,
    MediaChangeSkip         = 413,
    NoAuthData              = 414,
    NotAFile                = 415,
    MediumNotDesired        = 416,
    LastClientErrCode       = 499,
 
    FirstSrvErrCode    = 500,
    InternalError      = 500,
    ProtocolError      = 501,
    LastSrvErrCode     = 599,
 
    FirstControllerCode = 600,
    Prov                = 600,
    Cancel              = 601,
    Attach              = 602,
    Detach              = 603,
    LastControllerCode  = 699,
 
    FirstWorkerCode     = 700,
    AuthDataRequest     = 700,
    MediaChangeRequest  = 701,
    LastWorkerCode      = 799,
  };
 
  class ProviderConfiguration : public std::map<std::string, std::string>
  {
    public:
    using map::map;
 
    static constexpr std::string_view typeName = "ProviderConfiguration";
    zyppng::expected<zypp::PluginFrame> toStompMessage() const;
    static zyppng::expected<ProviderConfiguration> fromStompMessage( const zypp::PluginFrame &msg );
  };
 
  class WorkerCaps
  {
  public:
    enum WorkerType : uint32_t {
      Invalid       = 0,
      Downloading   = 1,
      SimpleMount   = 2,
      VolatileMount = 3,
      CPUBound      = 4,
    };
 
    enum Flags : uint32_t {
      None           = 0,   // Just for completeness
      SingleInstance = 1,   // If this flag is set a worker can only be started once, this is implicit in some worker types.
      Pipeline       = 2,   // The worker can handle multiple requests at the same time
      ZyppLogFormat  = 4,   // The worker writes messages to stderr in zypp log format
      FileArtifacts  = 8,   // The results of this worker are artifacts, which means they need to be cleaned up. This is implicit for all downloading workers. For all mounting workers this is ignored.
                            // CPU bound workers can use it to signal they leave artifact files behind that need to be cleaned up
    };
 
    explicit WorkerCaps();
    ~WorkerCaps();
 
    WorkerCaps(const WorkerCaps &) = default;
    WorkerCaps(WorkerCaps &&) = default;
    WorkerCaps &operator=(const WorkerCaps &) = default;
    WorkerCaps &operator=(WorkerCaps &&) = default;
 
    uint32_t protocol_version() const; // The workers should set this field to the protocol version they implement.
    WorkerType worker_type() const;
    Flags  cfg_flags() const;
    const std::string &worker_name() const;
 
    void set_protocol_version( uint32_t v );
    void set_worker_type( WorkerType t );
    void set_cfg_flags( Flags f );
    void set_worker_name( std::string name );
 
    static constexpr std::string_view typeName = "WorkerCaps";
    zyppng::expected<zypp::PluginFrame> toStompMessage() const;
    static zyppng::expected<WorkerCaps> fromStompMessage( const zypp::PluginFrame &msg );
 
  private:
    uint32_t    _protocolVersion = 1;
    uint32_t    _workerType      = Invalid;
    uint32_t    _cfgFlags        = None;
    std::string _workerName;
  };
 
  namespace ProvideMessageFields {
    constexpr std::string_view RequestCode("requestCode");
    constexpr std::string_view RequestId("requestId");
  }
 
  namespace ProvideStartedMsgFields
  {
    constexpr std::string_view Url ("url");
    constexpr std::string_view LocalFilename ("local_filename");
    constexpr std::string_view StagingFilename ("staging_filename");
  }
 
  namespace ProvideFinishedMsgFields
  {
    constexpr std::string_view LocalFilename ("local_filename");
    constexpr std::string_view CacheHit ("cacheHit");
  }
 
  namespace AuthInfoMsgFields
  {
    constexpr std::string_view Username ("username");
    constexpr std::string_view Password ("password");
    constexpr std::string_view AuthTimestamp ("auth_timestamp");
    constexpr std::string_view AuthType ("authType");
  }
 
  namespace RedirectMsgFields
  {
    constexpr std::string_view NewUrl ("new_url");
  }
 
  namespace MetalinkRedirectMsgFields
  {
    constexpr std::string_view NewUrl ("new_url");
  }
 
  namespace ErrMsgFields
  {
    constexpr std::string_view Reason ("reason");
    constexpr std::string_view Transient ("transient");
    constexpr std::string_view History ("history");
  }
 
  namespace ProvideMsgFields
  {
    constexpr std::string_view Url ("url");
    constexpr std::string_view Filename ("filename");
    constexpr std::string_view DeltaFile ("delta_file");
    constexpr std::string_view ExpectedFilesize ("expected_filesize");
    constexpr std::string_view CheckExistOnly ("check_existance_only");
    constexpr std::string_view MetalinkEnabled ("metalink_enabled");
  }
 
  namespace AttachMsgFields
  {
    constexpr std::string_view Url ("url");
    constexpr std::string_view AttachId ("attach_id");
    constexpr std::string_view VerifyType ("verify_type");
    constexpr std::string_view VerifyData ("verify_data");
    constexpr std::string_view MediaNr ("media_nr");
    constexpr std::string_view Device  ("device");
    constexpr std::string_view Label   ("label");
  }
 
  namespace AttachFinishedMsgFields
  {
    constexpr std::string_view LocalMountPoint ("local_mountpoint");
  }
 
  namespace DetachMsgFields
  {
    constexpr std::string_view Url ("url");
  }
 
  namespace AuthDataRequestMsgFields
  {
    constexpr std::string_view EffectiveUrl ("effective_url");
    constexpr std::string_view LastAuthTimestamp ("last_auth_timestamp");
    constexpr std::string_view LastUser ("username");
    constexpr std::string_view AuthHint ("authHint");
  }
 
  namespace MediaChangeRequestMsgFields
  {
    constexpr std::string_view Label ("label");
    constexpr std::string_view MediaNr ("media_nr");
    constexpr std::string_view Device ("device");
    constexpr std::string_view Desc ("desc");
  }
 
  namespace EjectMsgFields
  {
    constexpr std::string_view device ("device");
  }
 
  class ProvideMessage
  {
  public:
    using Code = MessageCodes;
 
    ProvideMessage(const ProvideMessage &) = default;
    ProvideMessage(ProvideMessage &&) = default;
    ProvideMessage &operator=(const ProvideMessage &) = default;
    ProvideMessage &operator=(ProvideMessage &&) = default;
    using FieldVal = HeaderValue;
 
    static constexpr std::string_view typeName = "ProvideMessage";
 
    static expected<ProvideMessage> create ( const zypp::PluginFrame &message );
    expected<zypp::PluginFrame>     toStompMessage() const;
    static expected<ProvideMessage> fromStompMessage( const zypp::PluginFrame &msg );
 
    static ProvideMessage createProvideStarted  ( const uint32_t reqId, const zypp::Url &url , const std::optional<std::string> &localFilename = {}, const std::optional<std::string> &stagingFilename = {} );
    static ProvideMessage createProvideFinished ( const uint32_t reqId, const std::string &localFilename , bool cacheHit );
    static ProvideMessage createAttachFinished  ( const uint32_t reqId, const std::optional<std::string> &localMountPoint = {} );
    static ProvideMessage createDetachFinished  ( const uint32_t reqId );
    static ProvideMessage createAuthInfo ( const uint32_t reqId, const std::string &user, const std::string &pw, int64_t timestamp, const std::map<std::string, std::string> &extraValues = {} );
    static ProvideMessage createMediaChanged ( const uint32_t reqId );
    static ProvideMessage createRedirect ( const uint32_t reqId, const zypp::Url &newUrl );
    static ProvideMessage createMetalinkRedir ( const uint32_t reqId, const std::vector<zypp::Url> &newUrls );
    static ProvideMessage createErrorResponse (const uint32_t reqId, const Code code, const std::string &reason, bool transient = false  );
 
    static ProvideMessage createProvide         ( const uint32_t reqId
                                                  , const zypp::Url &url
                                                  , const std::optional<std::string> &filename = {}
                                                  , const std::optional<std::string> &deltaFile = {}
                                                  , const std::optional<int64_t> &expFilesize = {}
                                                  , bool checkExistOnly = false );
 
    static ProvideMessage createCancel          ( const uint32_t reqId );
 
    static ProvideMessage createAttach( const uint32_t reqId
                                      , const zypp::Url &url
                                      , const std::string attachId
                                      , const std::string &label
                                      , const std::optional<std::string> &verifyType = {}
                                      , const std::optional<std::string> &verifyData = {}
                                      , const std::optional<int32_t> &mediaNr = {} );
 
    static ProvideMessage createDetach              ( const uint32_t reqId, const zypp::Url &attachUrl );
    static ProvideMessage createAuthDataRequest     ( const uint32_t reqId, const zypp::Url &effectiveUrl, const std::string &lastTriedUser ="", const std::optional<int64_t> &lastAuthTimestamp = {}, const std::map<std::string, std::string> &extraValues = {} );
    static ProvideMessage createMediaChangeRequest  ( const uint32_t reqId, const std::string &label, int32_t mediaNr, const std::vector<std::string> &devices, const std::optional<std::string> &desc );
 
    uint requestId () const;
    void setRequestId ( const uint id );
 
    Code code() const;
    void setCode (const Code newCode );
 
    const std::vector<ProvideMessage::FieldVal> &values ( const std::string_view &str ) const;
    const std::vector<ProvideMessage::FieldVal> &values ( const std::string &str ) const;
    const HeaderValueMap &headers() const;
    FieldVal value ( const std::string_view &str, const FieldVal &defaultVal = FieldVal() ) const;
    FieldVal value ( const std::string &str, const FieldVal &defaultVal = FieldVal() ) const;
    void setValue  ( const std::string &name, const FieldVal &value );
    void setValue  ( const std::string_view &name, const FieldVal &value );
    void addValue  ( const std::string &name, const FieldVal &value );
    void addValue  ( const std::string_view &name, const FieldVal &value );
 
  private:
    ProvideMessage();
    uint _reqId = -1;
    Code _code = NoCode;
    HeaderValueMap _headers;
  };
}
 
#endif