providequeue_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_QUEUE_P_H_INCLUDED
#define ZYPP_MEDIA_PRIVATE_PROVIDE_QUEUE_P_H_INCLUDED
 
#include "providefwd_p.h"
#include <zypp-media/ng/Provide>
#include <zypp-proto/media/provider.pb.h>
#include <zypp-core/zyppng/io/Process>
#include <zypp-core/ByteCount.h>
 
#include <deque>
#include <chrono>
#include <variant>
 
namespace zyppng {
 
  class RpcMessageStream;
  using RpcMessageStreamPtr = std::shared_ptr<RpcMessageStream>;
 
  class ProvideQueue : public Base
  {
  public:
    friend struct ProvideResourceData;
 
    static constexpr uint32_t InvalidId = (uint32_t) -1;
    using Config = zypp::proto::Capabilities;
 
    using TimePoint = std::chrono::time_point<std::chrono::steady_clock>;
 
    struct Item {
 
      enum State {
        Pending,
        Queued,
        Running,
        Cancelling,
        Finished
      };
      State _state = Pending;
      bool isAttachRequest () const;
      bool isFileRequest () const;
      bool isDetachRequest() const;
 
      ProvideRequestRef _request;
    };
 
    ProvideQueue( ProvidePrivate &parent );
    ~ProvideQueue();
    bool startup ( const std::string &workerScheme, const zypp::Pathname &workDir, const std::string &hostname = "" );
    void enqueue ( ProvideRequestRef request );
    void cancel  ( ProvideRequest *item, std::exception_ptr error );
    void detach  ( const std::string &id );
    void scheduleNext ();
    bool canScheduleMore () const;;
    bool empty () const;
 
    bool isIdle () const;
 
    std::optional<TimePoint> idleSince () const;
 
    uint requestCount () const;
 
    uint activeRequests () const;
 
    zypp::ByteCount expectedProvideSize() const;
 
    const std::string &hostname () const;
 
    const Config &workerConfig () const;
 
    SignalProxy<void()> sigIdle();
 
  private:
    bool doStartup ();
    void processMessage ( );
    void readAllStderr ();
    void forwardToLog ( std::string &&logLine );
    void processReadyRead( int channel );
    void procFinished ( int exitCode );
    uint32_t nextRequestId();
 
    std::list< ProvideQueue::Item >::iterator dequeueActive ( std::list<Item>::iterator it );
    void fatalWorkerError ( const std::exception_ptr &reason = nullptr );
    void immediateShutdown ( const std::exception_ptr &reason );
 
    std::list< ProvideQueue::Item >::iterator  cancelActiveItem (std::list<Item>::iterator i,  const std::exception_ptr &error );
 
  private:
    bool _queueShuttingDown = false;
    uint8_t  _crashCounter = 0;
    Config _capabilities;
    zypp::Pathname _currentExe;
    std::string _myHostname;
    ProvidePrivate &_parent;
    std::deque< Item > _waitQueue;
    std::list< Item >  _activeItems;
    Process::Ptr _workerProc;
    RpcMessageStreamPtr _messageStream;
    Signal<void()> _sigIdle;
    std::optional<TimePoint> _idleSince;
  };
 
}
 
#endif