nc_trans.h

Go to the documentation of this file.

// Copyright (C) 2013-2021 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 <exceptions/exceptions.h>
#include <d2/d2_cfg_mgr.h>
#include <d2/dns_client.h>
#include <dhcp_ddns/ncr_msg.h>
#include <dns/tsig.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 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();

    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_;

    dns::TSIGKeyPtr tsig_key_;
};

typedef boost::shared_ptr<NameChangeTransaction> NameChangeTransactionPtr;

} // namespace isc::d2
} // namespace isc
#endif