Commit a64f318c authored by Stephen Morris's avatar Stephen Morris

[2342] Move creation of MYSQL_BIND array for lease addition to separate class

parent 93ffcbb3
......@@ -25,6 +25,145 @@ using namespace std;
namespace isc {
namespace dhcp {
/// @brief Exchange MySQL Structure for Lease6
///
/// On the INSERT, SELECT and UPDATE statements, an array of MYSQL_BIND
/// structures must be built to reflect the data being inserted or retrieved
/// from the database.
///
/// Owing to the MySQL API, this process requires some intermediate variables
/// to hold things like length etc. This object holds the intermediate
/// variables and can:
/// 1. Build the MYSQL_BIND structures for a Lease6 object ready for passing
/// in to the MYSQL code.
/// 1. Copy information from the MYSQL_BIND structures into a Lease6 object.
class MySqlLease6Exchange {
public:
/// @brief Constructor
MySqlLease6Exchange() : false_(0), true_(1) {
}
/// @brief Create MYSQL_BIND objects for Lease6 Pointer
///
/// Fills in the bind_ objects for the Lease6 passed to it.
///
/// The MySQL documentation
///
/// @param lease Lease object to be added to the database
///
/// @return Pointer to MYSQL_BIND array holding the bind information.
/// This is a pointer to data internal to this object, and remains
/// valid only for as long as (1) this object is in existence and
/// (2) the lease object passed to it is in existence. The
/// caller should NOT delete it.
MYSQL_BIND* createBindFromLease(const Lease6Ptr& lease) {
// Store lease object to ensure it remains valid.
lease_ = lease;
// Ensure bind array clear.
memset(bind_, 0, sizeof(bind_));
// address: varchar(40)
addr6_ = lease_->addr_.toText();
addr6_length_ = addr6_.size();
bind_[0].buffer_type = MYSQL_TYPE_STRING;
bind_[0].buffer = const_cast<char*>(addr6_.c_str());
bind_[0].buffer_length = addr6_length_;
bind_[0].length = &addr6_length_;
// hwaddr: binary(20)
hwaddr_length_ = lease_->hwaddr_.size();
bind_[1].buffer_type = MYSQL_TYPE_BLOB;
bind_[1].buffer = reinterpret_cast<char*>(&(lease_->hwaddr_[0]));
bind_[1].buffer_length = hwaddr_length_;
bind_[1].length = &hwaddr_length_;
// client_id: varchar(128)
clientid_ = lease_->duid_->getDuid();
clientid_length_ = clientid_.size();
bind_[2].buffer_type = MYSQL_TYPE_BLOB;
bind_[2].buffer = reinterpret_cast<char*>(&(clientid_[0]));
bind_[2].buffer_length = clientid_length_;
bind_[2].length = &clientid_length_;
// The lease structure holds the client last transmission time (cltt_)
// and the valid lifetime (valid_lft_). For convenience for external
// tools, the data stored in the database is expiry time (expire) and
// lease time (lease+time). The relationship is given by:
//
// lease_time - valid_lft_
// expire = cltt_ + valid_lft_
//
MySqlLeaseMgr::convertToDatabaseTime(lease_->cltt_, lease_->valid_lft_,
expire_, lease_time_);
// lease_time: unsigned int
bind_[3].buffer_type = MYSQL_TYPE_LONG;
bind_[3].buffer = reinterpret_cast<char*>(&lease_time_);
bind_[3].is_unsigned = true_;
// expire: timestamp
bind_[4].buffer_type = MYSQL_TYPE_TIMESTAMP;
bind_[4].buffer = reinterpret_cast<char*>(&expire_);
bind_[4].buffer_length = sizeof(expire_);
// subnet_id: unsigned int
// Can use lease_->subnet_id_ directly as it is of type uint32_t.
bind_[5].buffer_type = MYSQL_TYPE_LONG;
bind_[5].buffer = reinterpret_cast<char*>(&lease_->subnet_id_);
bind_[5].is_unsigned = true_;
// pref_lifetime: unsigned int
// Can use lease_->preferred_lft_ directly as it is of type uint32_t.
bind_[6].buffer_type = MYSQL_TYPE_LONG;
bind_[6].buffer = reinterpret_cast<char*>(&lease_->preferred_lft_);
bind_[6].is_unsigned = true_;
// lease_type: tinyint
// Must convert to uint8_t as lease_->type_ is a LeaseType variable
lease_type_ = lease_->type_;
bind_[7].buffer_type = MYSQL_TYPE_TINY;
bind_[7].buffer = reinterpret_cast<char*>(&lease_type_);
bind_[7].is_unsigned = static_cast<my_bool>(1);
// iaid: unsigned int
// Can use lease_->iaid_ directly as it is of type uint32_t.
bind_[8].buffer_type = MYSQL_TYPE_LONG;
bind_[8].buffer = reinterpret_cast<char*>(&lease_->iaid_);
bind_[8].is_unsigned = true_;
// prefix_len: unsigned tinyint
// Can use lease_->prefixlen_ directly as it is uint32_t.
bind_[9].buffer_type = MYSQL_TYPE_TINY;
bind_[9].buffer = reinterpret_cast<char*>(&lease_->prefixlen_);
bind_[9].is_unsigned = true_;
return(bind_);
}
private:
std::string addr6_; ///< String form of address
unsigned long addr6_length_; ///< Length of the address
MYSQL_BIND bind_[10]; ///< Static array for speed of access
std::vector<uint8_t> clientid_; ///< Client identification
unsigned long clientid_length_; ///< Length of client ID
MYSQL_TIME expire_; ///< Lease expiry time
const my_bool false_; ///< "false" for MySql
unsigned long hwaddr_length_; ///< Length of hardware address
Lease6Ptr lease_; ///< Pointer to lease object
uint32_t lease_time_; ///< Lease time
uint8_t lease_type_; ///< Lease type
const my_bool true_; ///< "true_" for MySql
};
///
// Time conversion methods.
//
// Note that the MySQL TIMESTAMP data type (used for "expire") converts data
......@@ -33,7 +172,7 @@ namespace dhcp {
// must be local time.
void
MySqlLeaseMgr::convertFromLeaseTime(time_t cltt, uint32_t valid_lft,
MySqlLeaseMgr::convertToDatabaseTime(time_t cltt, uint32_t valid_lft,
MYSQL_TIME& expire, uint32_t& lease_time) {
// Calculate expiry time and convert to various date/time fields.
......@@ -56,7 +195,7 @@ MySqlLeaseMgr::convertFromLeaseTime(time_t cltt, uint32_t valid_lft,
}
void
MySqlLeaseMgr::convertToLeaseTime(const MYSQL_TIME& expire, uint32_t lease_time,
MySqlLeaseMgr::convertFromDatabaseTime(const MYSQL_TIME& expire, uint32_t lease_time,
time_t& cltt, uint32_t& valid_lft) {
valid_lft = lease_time;
......@@ -219,94 +358,9 @@ MySqlLeaseMgr::addLease(const Lease4Ptr& /* lease */) {
bool
MySqlLeaseMgr::addLease(const Lease6Ptr& lease) {
my_bool MLM_FALSE = 0;
MYSQL_BIND bind[10];
memset(bind, 0, sizeof(bind));
// address: varchar(40)
std::string addr6 = lease->addr_.toText();
unsigned long addr6_length = addr6.size();
bind[0].buffer_type = MYSQL_TYPE_STRING;
bind[0].buffer = const_cast<char*>(addr6.c_str());
bind[0].buffer_length = addr6_length;
bind[0].length = &addr6_length;
bind[0].is_null = &MLM_FALSE;
// hwaddr: binary(20)
unsigned long hwaddr_length = lease->hwaddr_.size();
bind[1].buffer_type = MYSQL_TYPE_BLOB;
bind[1].buffer = reinterpret_cast<char*>(&(lease->hwaddr_[0]));
bind[1].buffer_length = hwaddr_length;
bind[1].length = &hwaddr_length;
bind[1].is_null = &MLM_FALSE;
// client_id: varchar(128)
vector<uint8_t> clientid = lease->duid_->getDuid();
unsigned long clientid_length = clientid.size();
bind[2].buffer_type = MYSQL_TYPE_BLOB;
bind[2].buffer = reinterpret_cast<char*>(&(clientid[0]));
bind[2].buffer_length = clientid_length;
bind[2].length = &clientid_length;
bind[2].is_null = &MLM_FALSE;
// The lease structure holds the client last transmission time (cltt_)
// and the valid lifetime (valid_lft_). For convenience, the data stored
// in the database is expiry time (expire) and lease time (lease+time).
// The relationship is given by:
//
// lease_time - valid_lft_
// expire = cltt_ + valid_lft_
MYSQL_TIME mysql_expire;
uint32_t lease_time;
convertFromLeaseTime(lease->cltt_, lease->valid_lft_,
mysql_expire, lease_time);
// lease_time: unsigned int
bind[3].buffer_type = MYSQL_TYPE_LONG;
bind[3].buffer = reinterpret_cast<char*>(&lease_time);
bind[3].is_unsigned = 1;
bind[3].is_null = &MLM_FALSE;
// expire: timestamp
bind[4].buffer_type = MYSQL_TYPE_TIMESTAMP;
bind[4].buffer = reinterpret_cast<char*>(&mysql_expire);
bind[4].buffer_length = sizeof(mysql_expire);
bind[4].is_null = &MLM_FALSE;
// subnet_id: unsigned int
bind[5].buffer_type = MYSQL_TYPE_LONG;
bind[5].buffer = reinterpret_cast<char*>(&(lease->subnet_id_));
bind[5].is_unsigned = static_cast<my_bool>(1);
bind[5].is_null = &MLM_FALSE;
// pref_lifetime: unsigned int
bind[6].buffer_type = MYSQL_TYPE_LONG;
bind[6].buffer = reinterpret_cast<char*>(&(lease->preferred_lft_));
bind[6].is_unsigned = static_cast<my_bool>(1);
bind[6].is_null = &MLM_FALSE;
// lease_type: tinyint
uint8_t lease_type = lease->type_; // Needed for int -> uint8_t conversion
bind[7].buffer_type = MYSQL_TYPE_TINY;
bind[7].buffer = reinterpret_cast<char*>(&lease_type);
bind[7].is_unsigned = static_cast<my_bool>(1);
bind[7].is_null = &MLM_FALSE;
// iaid: unsigned int
bind[8].buffer_type = MYSQL_TYPE_LONG;
bind[8].buffer = reinterpret_cast<char*>(&(lease->iaid_));
bind[8].is_unsigned = static_cast<my_bool>(1);
bind[8].is_null = &MLM_FALSE;
// prefix_len: unsigned tinyint
bind[9].buffer_type = MYSQL_TYPE_TINY;
bind[9].buffer = reinterpret_cast<char*>(&(lease->prefixlen_));
bind[9].is_unsigned = static_cast<my_bool>(1);
bind[9].is_null = &MLM_FALSE;
// Create the MYSQL_BIND array for the lease
MySqlLease6Exchange exchange;
MYSQL_BIND* bind = exchange.createBindFromLease(lease);
// Bind the parameters to the statement
my_bool status = mysql_stmt_bind_param(statements_[INSERT_LEASE6], bind);
......@@ -458,8 +512,8 @@ MySqlLeaseMgr::getLease6(const isc::asiolink::IOAddress& addr) const {
result->addr_ = addr;
result->hwaddr_ = vector<uint8_t>(&hwaddr[0], &hwaddr[hwaddr_length]);
result->duid_.reset(new DUID(clientid, clientid_length));
convertToLeaseTime(mysql_expire, lease_time,
result->cltt_, result->valid_lft_);
convertFromDatabaseTime(mysql_expire, lease_time,
result->cltt_, result->valid_lft_);
result->subnet_id_ = subnet_id;
result->preferred_lft_ = pref_lifetime;
switch (lease_type) {
......
......@@ -69,13 +69,13 @@ public:
/// @exception DbOperationError Database function failed
virtual bool addLease(const Lease6Ptr& lease);
/// @brief Returns existing IPv4 lease for specified IPv4 address and subnet_id
/// @brief Return IPv4 lease for specified IPv4 address and subnet_id
///
/// This method is used to get a lease for specific subnet_id. There can be
/// at most one lease for any given subnet, so this method returns a single
/// pointer.
///
/// @param addr address of the searched lease
/// @param addr address of the sought lease
/// @param subnet_id ID of the subnet the lease must belong to
///
/// @return smart pointer to the lease (or NULL if a lease is not found)
......@@ -254,11 +254,11 @@ public:
///@{
/// The following methods are used to convert between times and time
/// intervals stored in the server in the Lease object, and the times
/// stored in the database. The reason for the difference is because
/// in the DHCP server, the cltt (Client Time Since Last Transmission)
/// is the natural data: in the lease file - which may be read by the
/// user - it is the expiry time of the lease.
/// intervals stored in the Lease object, and the times stored in the
/// database. The reason for the difference is because in the DHCP server,
/// the cltt (Client Time Since Last Transmission) is the natural data; in
/// the lease file - which may be read by the user - it is the expiry time
/// of the lease.
/// @brief Convert Lease Time to Database Times
///
......@@ -267,8 +267,8 @@ public:
/// is stored as lease_time (lease time) and expire (time of expiry of the
/// lease). They are related by the equations:
///
/// lease_time = valid_lft
/// expire = cltt + valid_lft
/// - lease_time = valid_lft
/// - expire = cltt + valid_lft
///
/// This method converts from the times in the lease object into times
/// able to be added to the database.
......@@ -280,7 +280,7 @@ public:
/// @param lease_time Reference to the time_t object where the lease time
/// will be put.
static
void convertFromLeaseTime(time_t cltt, uint32_t valid_lft,
void convertToDatabaseTime(time_t cltt, uint32_t valid_lft,
MYSQL_TIME& expire, uint32_t& lease_time);
/// @brief Convert Database Time to Lease Times
......@@ -288,10 +288,10 @@ public:
/// Within the database, time is stored as lease_time (lease time) and
/// expire (time of expiry of the lease). In the DHCP server, the
/// information is stored as cltt (client last transmit time) and
/// valid_lft (valid lifetime). These arr related by the equations:
/// valid_lft (valid lifetime). These are related by the equations:
///
/// valid_lft = lease_time
/// cltt = expire - lease_time
/// - valid_lft = lease_time
/// - cltt = expire - lease_time
///
/// This method converts from the times in the database into times
/// able to be inserted into the lease object.
......@@ -303,16 +303,16 @@ public:
/// is put.
/// @param valid_lft Reference to location where valid lifetime is put.
static
void convertToLeaseTime(const MYSQL_TIME& expire, uint32_t lease_time,
time_t& cltt, uint32_t& valid_lft);
void convertFromDatabaseTime(const MYSQL_TIME& expire, uint32_t lease_time,
time_t& cltt, uint32_t& valid_lft);
///@}
private:
/// @brief Enum of Statements
/// @brief Statement Tags
///
/// This is provided to set indexes into a list of prepared statements.
/// The contents of the enum are indexes into the list of SQL statements
enum StatementIndex {
GET_LEASE6,
GET_VERSION, // Obtain version number
......
......@@ -127,7 +127,7 @@ TEST_F(MySqlLeaseMgrTest, CheckTimeConversion) {
MYSQL_TIME expire;
uint32_t lease_time;
MySqlLeaseMgr::convertFromLeaseTime(cltt, valid_lft, expire, lease_time);
MySqlLeaseMgr::convertToDatabaseTime(cltt, valid_lft, expire, lease_time);
EXPECT_EQ(valid_lft, lease_time);
EXPECT_LE(2012, expire.year); // Code was written in 2012
EXPECT_EQ(0, expire.second_part);
......@@ -136,7 +136,7 @@ TEST_F(MySqlLeaseMgrTest, CheckTimeConversion) {
// Convert back
time_t converted_cltt = 0;
uint32_t converted_valid_lft = 0;
MySqlLeaseMgr::convertToLeaseTime(expire, lease_time, converted_cltt,
MySqlLeaseMgr::convertFromDatabaseTime(expire, lease_time, converted_cltt,
converted_valid_lft);
EXPECT_EQ(cltt, converted_cltt);
EXPECT_EQ(valid_lft, converted_valid_lft);
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment