Scheduler.h

#ifndef SCHEDULER_H_
#define SCHEDULER_H_

#include <arc/Thread.h>
#include <arc/Logger.h>
#include <arc/URL.h>
#include <arc/data/URLMap.h>

#include "DTR.h"
#include "DTRList.h"
#include "Processor.h"
#include "DataDelivery.h"
#include "TransferShares.h"

namespace DataStaging {


class Scheduler: public DTRCallback {   

  private:
  

    DTRList DtrList;
    

    std::list<std::string> cancelled_jobs;

    std::list<DTR_ptr> events;

    std::map<std::string, std::list<DTR_ptr> > staged_queue;

    Arc::SimpleCondition cancelled_jobs_lock;

    TransferSharesConf transferSharesConf;

    Arc::URLMap url_map;

    std::string preferred_pattern;
      
    Arc::SimpleCondition state_lock;

    Arc::SimpleCondition event_lock;

    Arc::SimpleCondition run_signal;

    Arc::SimpleCondition dump_signal;

    unsigned int PreProcessorSlots;
    unsigned int DeliverySlots;
    unsigned int PostProcessorSlots;
    unsigned int EmergencySlots;
    unsigned int StagedPreparedSlots;

    std::string dumplocation;

    std::vector<Arc::URL> configured_delivery_services;

    std::map<Arc::URL, std::vector<std::string> > usable_delivery_services;

    Arc::Time delivery_last_checked;

    unsigned long long int remote_size_limit;

    static Arc::Logger logger;

    std::list<Arc::LogDestination*> root_destinations;

    ProcessState scheduler_state;

    Processor processor;

    DataDelivery delivery;

    static Scheduler* scheduler_instance;

    static Glib::Mutex instance_lock;

    Scheduler(const Scheduler&); // should not happen
    Scheduler& operator=(const Scheduler&); // should not happen

    /* Functions to process every state of the DTR during normal workflow */

    void ProcessDTRNEW(DTR_ptr request);
    void ProcessDTRCACHE_WAIT(DTR_ptr request);
    void ProcessDTRCACHE_CHECKED(DTR_ptr request);
    void ProcessDTRRESOLVED(DTR_ptr request);
    void ProcessDTRREPLICA_QUERIED(DTR_ptr request);
    void ProcessDTRPRE_CLEANED(DTR_ptr request);
    void ProcessDTRSTAGING_PREPARING_WAIT(DTR_ptr request);
    void ProcessDTRSTAGED_PREPARED(DTR_ptr request);
    void ProcessDTRTRANSFERRED(DTR_ptr request);
    void ProcessDTRREQUEST_RELEASED(DTR_ptr request);
    void ProcessDTRREPLICA_REGISTERED(DTR_ptr request);
    void ProcessDTRCACHE_PROCESSED(DTR_ptr request);
    /* This is a special function to deal with states after which
     * the DTR is returned to the generator, i.e. DONE, ERROR, CANCELLED */
    void ProcessDTRFINAL_STATE(DTR_ptr request);
    
    void log_to_root_logger(Arc::LogLevel level, const std::string& message);

    void map_state_and_process(DTR_ptr request);
    

    void map_cancel_state(DTR_ptr request);
    
    void map_stuck_state(DTR_ptr request);

    void choose_delivery_service(DTR_ptr request);

    void revise_queues();

    void add_event(DTR_ptr event);

    void process_events(void);
    

    void next_replica(DTR_ptr request);


    bool handle_mapped_source(DTR_ptr request, Arc::URL& mapped_url);

    static void dump_thread(void* arg);

    static void main_thread(void* arg);
    void main_thread(void);

  public:
  

    static Scheduler* getInstance();

    Scheduler();

    ~Scheduler() { stop(); };

    /* The following Set/Add methods are only effective when called before start() */

    void SetSlots(int pre_processor = 0, int post_processor = 0,
                  int delivery = 0, int emergency = 0, int staged_prepared = 0);

    void AddURLMapping(const Arc::URL& template_url, const Arc::URL& replacement_url,
                       const Arc::URL& access_url = Arc::URL());

    void SetURLMapping(const Arc::URLMap& mapping = Arc::URLMap());


    void SetPreferredPattern(const std::string& pattern);

    void SetTransferSharesConf(const TransferSharesConf& share_conf);

    void SetTransferParameters(const TransferParameters& params);

    void SetDeliveryServices(const std::vector<Arc::URL>& endpoints);

    void SetRemoteSizeLimit(unsigned long long int limit);

    void SetDumpLocation(const std::string& location);


    bool start(void);
    

    virtual void receiveDTR(DTR_ptr dtr);
    
    bool cancelDTRs(const std::string& jobid);


    bool stop();
  };
} // namespace DataStaging

#endif /*SCHEDULER_H_*/