2020-05-12 08:35:48 +00:00
|
|
|
/*
|
|
|
|
* Copyright (c)2013-2020 ZeroTier, Inc.
|
|
|
|
*
|
|
|
|
* Use of this software is governed by the Business Source License included
|
|
|
|
* in the LICENSE.TXT file in the project's root directory.
|
|
|
|
*
|
|
|
|
* Change Date: 2024-01-01
|
|
|
|
*
|
|
|
|
* On the date above, in accordance with the Business Source License, use
|
|
|
|
* of this software will be governed by version 2.0 of the Apache License.
|
|
|
|
*/
|
|
|
|
/****/
|
|
|
|
|
|
|
|
#ifndef ZT_SLAVE_HPP
|
|
|
|
#define ZT_SLAVE_HPP
|
|
|
|
|
|
|
|
#include <string>
|
|
|
|
|
|
|
|
#include "../node/AtomicCounter.hpp"
|
|
|
|
|
|
|
|
namespace ZeroTier {
|
|
|
|
|
|
|
|
class Slave
|
|
|
|
{
|
|
|
|
friend class SharedPtr<Slave>;
|
|
|
|
|
|
|
|
public:
|
|
|
|
|
|
|
|
Slave() {}
|
|
|
|
|
|
|
|
/**
|
|
|
|
*
|
|
|
|
* @param ifnameStr
|
|
|
|
* @param ipvPref
|
|
|
|
* @param speed
|
|
|
|
* @param enabled
|
|
|
|
* @param mode
|
|
|
|
* @param failoverToSlaveStr
|
|
|
|
* @param userSpecifiedAlloc
|
|
|
|
*/
|
|
|
|
Slave(std::string& ifnameStr,
|
|
|
|
uint8_t ipvPref,
|
|
|
|
uint32_t speed,
|
|
|
|
uint32_t slaveMonitorInterval,
|
|
|
|
uint32_t upDelay,
|
|
|
|
uint32_t downDelay,
|
|
|
|
bool enabled,
|
|
|
|
uint8_t mode,
|
|
|
|
std::string failoverToSlaveStr,
|
|
|
|
float userSpecifiedAlloc) :
|
|
|
|
_ifnameStr(ifnameStr),
|
|
|
|
_ipvPref(ipvPref),
|
|
|
|
_speed(speed),
|
|
|
|
_relativeSpeed(0),
|
|
|
|
_slaveMonitorInterval(slaveMonitorInterval),
|
|
|
|
_upDelay(upDelay),
|
|
|
|
_downDelay(downDelay),
|
|
|
|
_enabled(enabled),
|
|
|
|
_mode(mode),
|
|
|
|
_failoverToSlaveStr(failoverToSlaveStr),
|
|
|
|
_userSpecifiedAlloc(userSpecifiedAlloc),
|
|
|
|
_isUserSpecified(false)
|
|
|
|
{}
|
2020-05-15 03:09:25 +00:00
|
|
|
|
2020-05-12 08:35:48 +00:00
|
|
|
/**
|
|
|
|
* @return The string representation of this slave's underlying interface's system name.
|
|
|
|
*/
|
|
|
|
inline std::string ifname() { return _ifnameStr; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return Whether this slave is designated as a primary.
|
|
|
|
*/
|
|
|
|
inline bool primary() { return _mode == ZT_MULTIPATH_SLAVE_MODE_PRIMARY; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return Whether this slave is designated as a spare.
|
|
|
|
*/
|
|
|
|
inline bool spare() { return _mode == ZT_MULTIPATH_SLAVE_MODE_SPARE; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return The name of the slave interface that should be used in the event of a failure.
|
|
|
|
*/
|
|
|
|
inline std::string failoverToSlave() { return _failoverToSlaveStr; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return Whether this slave interface was specified by the user or auto-detected.
|
|
|
|
*/
|
|
|
|
inline bool isUserSpecified() { return _isUserSpecified; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Signify that this slave was specified by the user and not the result of auto-detection.
|
|
|
|
*
|
|
|
|
* @param isUserSpecified
|
|
|
|
*/
|
|
|
|
inline void setAsUserSpecified(bool isUserSpecified) { _isUserSpecified = isUserSpecified; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return Whether or not the user has specified failover instructions.
|
|
|
|
*/
|
|
|
|
inline bool userHasSpecifiedFailoverInstructions() { return _failoverToSlaveStr.length(); }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return The speed of the slave relative to others in the bond.
|
|
|
|
*/
|
|
|
|
inline uint8_t relativeSpeed() { return _relativeSpeed; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets the speed of the slave relative to others in the bond.
|
|
|
|
*
|
|
|
|
* @param relativeSpeed The speed relative to the rest of the slave interfaces.
|
|
|
|
*/
|
|
|
|
inline void setRelativeSpeed(uint8_t relativeSpeed) { _relativeSpeed = relativeSpeed; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Sets the speed of the slave relative to others in the bond.
|
|
|
|
*
|
|
|
|
* @param relativeSpeed
|
|
|
|
*/
|
|
|
|
inline void setMonitorInterval(uint32_t interval) { _slaveMonitorInterval = interval; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return The absolute speed of the slave interface (as specified by the user.)
|
|
|
|
*/
|
|
|
|
inline uint32_t monitorInterval() { return _slaveMonitorInterval; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return The absolute speed of the slave interface (as specified by the user.)
|
|
|
|
*/
|
|
|
|
inline uint32_t speed() { return _speed; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return The address preference for this slave interface (as specified by the user.)
|
|
|
|
*/
|
|
|
|
inline uint8_t ipvPref() { return _ipvPref; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return The mode (e.g. primary/spare) for this slave interface (as specified by the user.)
|
|
|
|
*/
|
|
|
|
inline uint8_t mode() { return _mode; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return The upDelay parameter for all paths on this slave interface.
|
|
|
|
*/
|
|
|
|
inline uint32_t upDelay() { return _upDelay; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return The downDelay parameter for all paths on this slave interface.
|
|
|
|
*/
|
|
|
|
inline uint32_t downDelay() { return _downDelay; }
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @return Whether this slave is enabled or disabled
|
|
|
|
*/
|
|
|
|
inline uint8_t enabled() { return _enabled; }
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
|
|
|
/**
|
|
|
|
* String representation of underlying interface's system name
|
|
|
|
*/
|
|
|
|
std::string _ifnameStr;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* What preference (if any) a user has for IP protocol version used in
|
|
|
|
* path aggregations. Preference is expressed in the order of the digits:
|
2020-05-15 03:09:25 +00:00
|
|
|
*
|
2020-05-12 08:35:48 +00:00
|
|
|
* 0: no preference
|
|
|
|
* 4: IPv4 only
|
|
|
|
* 6: IPv6 only
|
|
|
|
* 46: IPv4 over IPv6
|
|
|
|
* 64: IPv6 over IPv4
|
|
|
|
*/
|
|
|
|
uint8_t _ipvPref;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* User-specified speed of this slave/link
|
|
|
|
*/
|
|
|
|
uint32_t _speed;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Speed relative to other specified slaves/links (computed by Bond)
|
|
|
|
*/
|
|
|
|
uint8_t _relativeSpeed;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* User-specified interval for monitoring paths on this specific slave
|
|
|
|
* instead of using the more generic interval specified for the entire
|
|
|
|
* bond.
|
|
|
|
*/
|
|
|
|
uint32_t _slaveMonitorInterval;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* How long before a path is considered to be usable after coming online. (when using policies that
|
|
|
|
* support fail-over events).
|
|
|
|
*/
|
|
|
|
uint32_t _upDelay;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* How long before a path is considered to be dead (when using policies that
|
|
|
|
* support fail-over events).
|
|
|
|
*/
|
|
|
|
uint32_t _downDelay;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Whether this slave is enabled, or (disabled (possibly bad config))
|
|
|
|
*/
|
|
|
|
uint8_t _enabled;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Whether this slave is designated as a primary, a spare, or no preference.
|
|
|
|
*/
|
|
|
|
uint8_t _mode;
|
|
|
|
|
|
|
|
/**
|
2020-05-15 03:09:25 +00:00
|
|
|
* The specific name of the interface to be used in the event that this
|
2020-05-12 08:35:48 +00:00
|
|
|
* slave fails.
|
|
|
|
*/
|
|
|
|
std::string _failoverToSlaveStr;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* User-specified allocation
|
|
|
|
*/
|
|
|
|
float _userSpecifiedAlloc;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Whether or not this slave was created as a result of manual user specification. This is
|
|
|
|
* important to know because certain policy decisions are dependent on whether the user
|
|
|
|
* intents to use a specific set of interfaces.
|
|
|
|
*/
|
|
|
|
bool _isUserSpecified;
|
|
|
|
|
|
|
|
AtomicCounter __refCount;
|
|
|
|
};
|
|
|
|
|
|
|
|
} // namespace ZeroTier
|
|
|
|
|
|
|
|
#endif
|