Log burnt IP only once

[bpdyndnsd] / src / service.hpp

/** @file
 * @brief The abstract service class. This class represents all services.
 *
 *
 *
 * @copyright Intra2net AG
 * @license GPLv2
*/

#ifndef SERVICE_H
#define SERVICE_H

#include "logger.hpp"

#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>

#include <boost/shared_ptr.hpp>
#include <string>
#include <list>


class Service
{

private:

    std::string Protocol;
    std::string Hostname;

    std::string Login;
    std::string Password;

    std::string ActualIP;
    bool ActualIPIsBurnt;

    int UpdateInterval;
    int MaxUpdatesWithinInterval;
    int MaxEqualUpdatesInSuccession;
    int DNSCacheTTL;

    std::map<time_t,std::string> LastUpdates;

    int ErrorCount;
    time_t ErrorServiceBlockedUntil;

    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
        // protocol and hostname are the unique identifier for each service.
        ar & Protocol;
        ar & Hostname;
        // lastupdated and actual_ip must also be serialized, cause these are essential infos of each service.
        ar & LastUpdates;
        ar & ActualIP;
        ar & UpdateInterval;
        ar & MaxUpdatesWithinInterval;
        ar & MaxEqualUpdatesInSuccession;
        ar & DNSCacheTTL;
    }

    Logger::Ptr Log;

protected:

    enum UpdateErrorCode { UpdateOk=0, GenericError=1, NoChange=2, Blocked=3 };
    virtual UpdateErrorCode perform_update(const std::string& ip) = 0;

public:

    typedef boost::shared_ptr<Service> Ptr;

    Service();

    virtual ~Service();

    void update(const std::string& ip, const time_t current_time, bool changed_to_online);

    bool update_allowed(const time_t current_time, bool changed_to_online, const std::string& ip_host);

    void set_last_update(const time_t current_time, const std::string& ip);

    time_t get_last_update_time();

    int get_update_interval()const;
    void set_update_interval(const int _update_interval);

    int get_max_updates_within_interval() const;
    void set_max_updates_within_interval(const int _max_updates_within_interval);

    int get_max_equal_updates_in_succession() const;
    void set_max_equal_updates_in_succession(const int _max_equal_updates_in_succession);

    int get_dns_cache_ttl() const;
    void set_dns_cache_ttl(const int _dns_cache_ttl);

    void set_protocol(const std::string& _protocol);
    std::string get_protocol() const;

    void set_hostname(const std::string& _hostname);
    std::string get_hostname() const;

    void set_login(const std::string& _login);
    std::string get_login() const;

    void set_password(const std::string& _password);
    std::string get_password() const;

    void set_last_updates(std::map<time_t,std::string> _last_updates);
    const std::map<time_t,std::string> get_last_updates() const;

    void set_actual_ip(const std::string& _actual_ip);
    std::string get_actual_ip() const;

    void set_logger(const Logger::Ptr& _log);
    Logger::Ptr get_logger() const;

    std::string get_service_name() const;

    bool operator== (const Service& other) const;
    bool operator!= (const Service& other) const;
};

#endif