nc_trans.h

Go to the documentation of this file.

// Copyright (C) 2013-2024 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef NC_TRANS_H
#define NC_TRANS_H
 
 
#include <asiolink/io_service.h>
#include <d2srv/dns_client.h>
#include <d2srv/d2_cfg_mgr.h>
#include <d2srv/d2_tsig_key.h>
#include <dhcp_ddns/ncr_msg.h>
#include <exceptions/exceptions.h>
#include <util/state_model.h>
 
#include <boost/shared_ptr.hpp>
#include <map>
 
namespace isc {
namespace d2 {
 
class NameChangeTransactionError : public isc::Exception {
public:
    NameChangeTransactionError(const char* file, size_t line,
                               const char* what) :
        isc::Exception(file, line, what) { }
};
 
typedef isc::dhcp_ddns::D2Dhcid TransactionKey;
 
class NameChangeTransaction : public DNSClient::Callback, public util::StateModel {
public:
 
 
    static const int READY_ST = SM_DERIVED_STATE_MIN + 1;
 
    static const int SELECTING_FWD_SERVER_ST = SM_DERIVED_STATE_MIN + 2;
 
    static const int SELECTING_REV_SERVER_ST = SM_DERIVED_STATE_MIN + 3;
 
    static const int PROCESS_TRANS_OK_ST = SM_DERIVED_STATE_MIN + 4;
 
    static const int PROCESS_TRANS_FAILED_ST = SM_DERIVED_STATE_MIN + 5;
 
    static const int NCT_DERIVED_STATE_MIN = SM_DERIVED_STATE_MIN + 101;
 
 
    static const int SELECT_SERVER_EVT = SM_DERIVED_EVENT_MIN + 1;
 
    static const int SERVER_SELECTED_EVT = SM_DERIVED_EVENT_MIN + 2;
 
    static const int SERVER_IO_ERROR_EVT = SM_DERIVED_EVENT_MIN + 3;
 
 
    static const int NO_MORE_SERVERS_EVT =SM_DERIVED_EVENT_MIN +  4;
 
    static const int IO_COMPLETED_EVT = SM_DERIVED_EVENT_MIN + 5;
 
    static const int UPDATE_OK_EVT = SM_DERIVED_EVENT_MIN + 6;
 
    static const int UPDATE_FAILED_EVT = SM_DERIVED_EVENT_MIN + 7;
 
    static const int NCT_DERIVED_EVENT_MIN = SM_DERIVED_EVENT_MIN + 101;
 
    static const unsigned int DNS_UPDATE_DEFAULT_TIMEOUT = 100;
 
    static const unsigned int MAX_UPDATE_TRIES_PER_SERVER = 3;
 
    NameChangeTransaction(asiolink::IOServicePtr& io_service,
                          dhcp_ddns::NameChangeRequestPtr& ncr,
                          DdnsDomainPtr& forward_domain,
                          DdnsDomainPtr& reverse_domain,
                          D2CfgMgrPtr& cfg_mgr);
 
    virtual ~NameChangeTransaction();
 
    void startTransaction();
 
    virtual void operator()(DNSClient::Status status);
 
protected:
    virtual void sendUpdate(const std::string& comment = "");
 
    virtual void defineEvents();
 
    virtual void verifyEvents();
 
    virtual void defineStates();
 
    virtual void verifyStates();
 
    virtual void onModelFailure(const std::string& explanation);
 
    void retryTransition(const int fail_to_state);
 
    void setDnsUpdateRequest(D2UpdateMessagePtr& request);
 
    void clearDnsUpdateRequest();
 
    void clearUpdateAttempts();
 
    void setDnsUpdateStatus(const DNSClient::Status& status);
 
    void setDnsUpdateResponse(D2UpdateMessagePtr& response);
 
    void clearDnsUpdateResponse();
 
    void setForwardChangeCompleted(const bool value);
 
    void setReverseChangeCompleted(const bool value);
 
    void setNcrStatus(const dhcp_ddns::NameChangeStatus& status);
 
    void initServerSelection(const DdnsDomainPtr& domain);
 
    bool selectNextServer();
 
    bool selectTSIGKey();
 
    void setUpdateAttempts(const size_t value);
 
    const asiolink::IOServicePtr& getIOService() {
        return (io_service_);
    }
 
    virtual D2UpdateMessagePtr prepNewRequest(DdnsDomainPtr domain);
 
    void addLeaseAddressRdata(dns::RRsetPtr& rrset);
 
    void addDhcidRdata(dns::RRsetPtr& rrset);
 
    void addPtrRdata(dns::RRsetPtr& rrset);
 
    std::string responseString() const;
 
    std::string transactionOutcomeString() const;
 
public:
    const dhcp_ddns::NameChangeRequestPtr& getNcr() const;
 
    const TransactionKey& getTransactionKey() const;
 
    std::string getRequestId() const;
 
    dhcp_ddns::NameChangeStatus getNcrStatus() const;
 
    DdnsDomainPtr& getForwardDomain();
 
    DdnsDomainPtr& getReverseDomain();
 
    const DnsServerInfoPtr& getCurrentServer() const;
 
    const DNSClientPtr& getDNSClient() const;
 
    const D2UpdateMessagePtr& getDnsUpdateRequest() const;
 
    DNSClient::Status getDnsUpdateStatus() const;
 
    const D2UpdateMessagePtr& getDnsUpdateResponse() const;
 
    bool getForwardChangeCompleted() const;
 
    bool getReverseChangeCompleted() const;
 
    size_t getUpdateAttempts() const;
 
    const dns::RRType& getAddressRRType() const;
 
private:
    asiolink::IOServicePtr io_service_;
 
    dhcp_ddns::NameChangeRequestPtr ncr_;
 
    DdnsDomainPtr forward_domain_;
 
    DdnsDomainPtr reverse_domain_;
 
    DNSClientPtr dns_client_;
 
    D2UpdateMessagePtr dns_update_request_;
 
    DNSClient::Status dns_update_status_;
 
    D2UpdateMessagePtr dns_update_response_;
 
    bool forward_change_completed_;
 
    bool reverse_change_completed_;
 
    DnsServerInfoStoragePtr current_server_list_;
 
    DnsServerInfoPtr current_server_;
 
    size_t next_server_pos_;
 
    size_t update_attempts_;
 
    D2CfgMgrPtr cfg_mgr_;
 
    D2TsigKeyPtr tsig_key_;
};
 
typedef boost::shared_ptr<NameChangeTransaction> NameChangeTransactionPtr;
 
} // namespace isc::d2
} // namespace isc
#endif