mirror of
https://github.com/OpenNebula/one.git
synced 2026-11-19 03:12:55 +09:00
1097 lines
28 KiB
C++
1097 lines
28 KiB
C++
/* ------------------------------------------------------------------------ */
|
|
/* Copyright 2002-2018, OpenNebula Project, OpenNebula Systems */
|
|
/* */
|
|
/* Licensed under the Apache License, Version 2.0 (the "License"); you may */
|
|
/* not use this file except in compliance with the License. You may obtain */
|
|
/* a copy of the License at */
|
|
/* */
|
|
/* http://www.apache.org/licenses/LICENSE-2.0 */
|
|
/* */
|
|
/* Unless required by applicable law or agreed to in writing, software */
|
|
/* distributed under the License is distributed on an "AS IS" BASIS, */
|
|
/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. */
|
|
/* See the License for the specific language governing permissions and */
|
|
/* limitations under the License. */
|
|
/* ------------------------------------------------------------------------ */
|
|
|
|
#include "Datastore.h"
|
|
#include "GroupPool.h"
|
|
#include "NebulaLog.h"
|
|
#include "Nebula.h"
|
|
|
|
const char * Datastore::table = "datastore_pool";
|
|
|
|
const char * Datastore::db_names =
|
|
"oid, name, body, uid, gid, owner_u, group_u, other_u";
|
|
|
|
const char * Datastore::db_bootstrap =
|
|
"CREATE TABLE IF NOT EXISTS datastore_pool ("
|
|
"oid INTEGER PRIMARY KEY, name VARCHAR(128), body MEDIUMTEXT, uid INTEGER, "
|
|
"gid INTEGER, owner_u INTEGER, group_u INTEGER, other_u INTEGER)";
|
|
|
|
/* ************************************************************************ */
|
|
/* Datastore :: Constructor/Destructor */
|
|
/* ************************************************************************ */
|
|
|
|
Datastore::Datastore(
|
|
int uid,
|
|
int gid,
|
|
const string& uname,
|
|
const string& gname,
|
|
int umask,
|
|
DatastoreTemplate* ds_template,
|
|
const set<int> &cluster_ids):
|
|
PoolObjectSQL(-1,DATASTORE,"",uid,gid,uname,gname,table),
|
|
Clusterable(cluster_ids),
|
|
ds_mad(""),
|
|
tm_mad(""),
|
|
base_path(""),
|
|
type(IMAGE_DS),
|
|
disk_type(Image::FILE),
|
|
total_mb(0),
|
|
free_mb(0),
|
|
used_mb(0),
|
|
state(READY),
|
|
images("IMAGES")
|
|
{
|
|
if (ds_template != 0)
|
|
{
|
|
obj_template = ds_template;
|
|
}
|
|
else
|
|
{
|
|
obj_template = new DatastoreTemplate;
|
|
}
|
|
|
|
set_umask(umask);
|
|
|
|
group_u = 1;
|
|
}
|
|
|
|
Datastore::~Datastore(){};
|
|
|
|
/* ------------------------------------------------------------------------ */
|
|
/* ------------------------------------------------------------------------ */
|
|
|
|
int Datastore::enable(bool enable, string& error_str)
|
|
{
|
|
if (type != SYSTEM_DS)
|
|
{
|
|
error_str = "Only SYSTEM_DS can be disabled or enabled";
|
|
return -1;
|
|
}
|
|
|
|
|
|
if (enable)
|
|
{
|
|
state = READY;
|
|
}
|
|
else
|
|
{
|
|
state = DISABLED;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------ */
|
|
/* ------------------------------------------------------------------------ */
|
|
|
|
void Datastore::disk_attribute(
|
|
VirtualMachineDisk * disk,
|
|
const vector<string>& inherit_attrs)
|
|
{
|
|
string st, tm_mad;
|
|
string inherit_val;
|
|
string current_val;
|
|
string type;
|
|
|
|
vector<string>::const_iterator it;
|
|
|
|
disk->replace("DATASTORE", get_name());
|
|
disk->replace("DATASTORE_ID", oid);
|
|
disk->replace("TM_MAD", get_tm_mad());
|
|
|
|
set<int> cluster_ids = get_cluster_ids();
|
|
|
|
disk->replace("CLUSTER_ID", one_util::join(cluster_ids, ','));
|
|
|
|
tm_mad = disk->get_tm_mad_system();
|
|
|
|
if (!tm_mad.empty())
|
|
{
|
|
string tm_mad_t = one_util::trim(tm_mad);
|
|
tm_mad = one_util::toupper(tm_mad_t);
|
|
}
|
|
|
|
if (!tm_mad.empty())
|
|
{
|
|
get_template_attribute("CLONE_TARGET_" + tm_mad, st);
|
|
|
|
if (st.empty())
|
|
{
|
|
get_template_attribute("CLONE_TARGET", st);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
get_template_attribute("CLONE_TARGET", st);
|
|
}
|
|
|
|
if(!st.empty() && disk->vector_value("CLONE_TARGET").empty())
|
|
{
|
|
disk->replace("CLONE_TARGET", st);
|
|
}
|
|
|
|
if (!tm_mad.empty())
|
|
{
|
|
get_template_attribute("LN_TARGET_" + tm_mad, st);
|
|
|
|
if (st.empty())
|
|
{
|
|
get_template_attribute("LN_TARGET", st);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
get_template_attribute("LN_TARGET", st);
|
|
}
|
|
|
|
if(!st.empty() && disk->vector_value("LN_TARGET").empty())
|
|
{
|
|
disk->replace("LN_TARGET", st);
|
|
}
|
|
|
|
for (it = inherit_attrs.begin(); it != inherit_attrs.end(); it++)
|
|
{
|
|
current_val = disk->vector_value((*it).c_str());
|
|
get_template_attribute((*it).c_str(), inherit_val);
|
|
|
|
if ( current_val.empty() && !inherit_val.empty() )
|
|
{
|
|
disk->replace(*it, inherit_val);
|
|
}
|
|
}
|
|
|
|
if (!tm_mad.empty())
|
|
{
|
|
get_template_attribute("DISK_TYPE_" + tm_mad, st);
|
|
|
|
if (!st.empty())
|
|
{
|
|
disk->set_types(st);
|
|
}
|
|
}
|
|
else if (disk->is_volatile() && disk->vector_value("DISK_TYPE").empty())
|
|
{
|
|
disk->replace("DISK_TYPE", Image::disk_type_to_str(get_disk_type()));
|
|
}
|
|
|
|
type = disk->vector_value("TYPE");
|
|
|
|
if (type != "CDROM")
|
|
{
|
|
get_template_attribute("DRIVER", st);
|
|
|
|
if(!st.empty() && disk->vector_value("DRIVER").empty())
|
|
{
|
|
disk->replace("DRIVER", st);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ************************************************************************ */
|
|
/* Datastore :: Database Access Functions */
|
|
/* ************************************************************************ */
|
|
|
|
Datastore::DatastoreType Datastore::str_to_type(string& str_type)
|
|
{
|
|
Datastore::DatastoreType dst = IMAGE_DS;
|
|
|
|
if (str_type.empty())
|
|
{
|
|
return dst;
|
|
}
|
|
|
|
one_util::toupper(str_type);
|
|
|
|
if ( str_type == "IMAGE_DS" )
|
|
{
|
|
dst = IMAGE_DS;
|
|
}
|
|
else if ( str_type == "SYSTEM_DS" )
|
|
{
|
|
dst = SYSTEM_DS;
|
|
}
|
|
else if ( str_type == "FILE_DS" )
|
|
{
|
|
dst = FILE_DS;
|
|
}
|
|
|
|
return dst;
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
static int check_tm_target_type(string& tm_tt)
|
|
{
|
|
if (tm_tt.empty())
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
one_util::toupper(tm_tt);
|
|
|
|
if ((tm_tt != "NONE") && (tm_tt != "SELF") && (tm_tt != "SYSTEM"))
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
int Datastore::set_ds_mad(std::string &mad, std::string &error_str)
|
|
{
|
|
const VectorAttribute* vatt;
|
|
std::vector <std::string> vrequired_attrs;
|
|
|
|
int rc;
|
|
std::string required_attrs, required_attr, value;
|
|
|
|
std::ostringstream oss;
|
|
|
|
if ( type == SYSTEM_DS ) //No ds_mad for SYSTEM_DS
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
rc = Nebula::instance().get_ds_conf_attribute(mad, vatt);
|
|
|
|
if ( rc != 0 )
|
|
{
|
|
goto error_conf;
|
|
}
|
|
|
|
rc = vatt->vector_value("REQUIRED_ATTRS", required_attrs);
|
|
|
|
if ( rc == -1 ) //No required attributes
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
vrequired_attrs = one_util::split(required_attrs, ',');
|
|
|
|
for ( std::vector<std::string>::const_iterator it = vrequired_attrs.begin();
|
|
it != vrequired_attrs.end(); it++ )
|
|
{
|
|
required_attr = *it;
|
|
|
|
required_attr = one_util::trim(required_attr);
|
|
one_util::toupper(required_attr);
|
|
|
|
get_template_attribute(required_attr.c_str(), value);
|
|
|
|
if ( value.empty() )
|
|
{
|
|
goto error_required;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
|
|
error_conf:
|
|
oss << "DS_MAD named \"" << mad << "\" is not defined in oned.conf";
|
|
goto error_common;
|
|
|
|
error_required:
|
|
oss << "Datastore template is missing the \"" << required_attr
|
|
<< "\" attribute or it's empty.";
|
|
|
|
error_common:
|
|
error_str = oss.str();
|
|
return -1;
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
int Datastore::set_tm_mad(string &tm_mad, string &error_str)
|
|
{
|
|
const VectorAttribute* vatt;
|
|
|
|
std::vector<std::string> modes;
|
|
|
|
ostringstream oss;
|
|
std::stringstream ss;
|
|
|
|
if ( Nebula::instance().get_tm_conf_attribute(tm_mad, vatt) != 0 )
|
|
{
|
|
goto error_conf;
|
|
}
|
|
|
|
if (type == SYSTEM_DS)
|
|
{
|
|
bool shared_type;
|
|
bool ds_migrate;
|
|
|
|
if (vatt->vector_value("SHARED", shared_type) == -1)
|
|
{
|
|
goto error;
|
|
}
|
|
|
|
if (shared_type)
|
|
{
|
|
replace_template_attribute("SHARED", "YES");
|
|
}
|
|
else
|
|
{
|
|
replace_template_attribute("SHARED", "NO");
|
|
}
|
|
|
|
if (vatt->vector_value("DS_MIGRATE", ds_migrate) == -1)
|
|
{
|
|
ds_migrate = true;
|
|
}
|
|
|
|
if (ds_migrate)
|
|
{
|
|
replace_template_attribute("DS_MIGRATE", "YES");
|
|
}
|
|
else
|
|
{
|
|
replace_template_attribute("DS_MIGRATE", "NO");
|
|
}
|
|
|
|
remove_template_attribute("LN_TARGET");
|
|
remove_template_attribute("CLONE_TARGET");
|
|
}
|
|
else
|
|
{
|
|
string st = vatt->vector_value("TM_MAD_SYSTEM");
|
|
|
|
if (!st.empty())
|
|
{
|
|
std::vector<std::string>::iterator it;
|
|
|
|
replace_template_attribute("TM_MAD_SYSTEM", st);
|
|
|
|
modes = one_util::split(st, ',', true);
|
|
|
|
string s;
|
|
|
|
for (it = modes.begin() ; it != modes.end(); ++it)
|
|
{
|
|
string tm_mad_t = one_util::trim(*it);
|
|
string tm_mad = one_util::toupper(tm_mad_t);
|
|
|
|
st = vatt->vector_value("LN_TARGET_" + tm_mad);
|
|
|
|
if (check_tm_target_type(st) == -1)
|
|
{
|
|
goto error;
|
|
}
|
|
|
|
replace_template_attribute("LN_TARGET_" + tm_mad, st);
|
|
|
|
st = vatt->vector_value("CLONE_TARGET_" + tm_mad);
|
|
|
|
if (check_tm_target_type(st) == -1)
|
|
{
|
|
goto error;
|
|
}
|
|
|
|
replace_template_attribute("CLONE_TARGET_" + tm_mad, st);
|
|
|
|
st = vatt->vector_value("DISK_TYPE_" + tm_mad);
|
|
|
|
if (st.empty())
|
|
{
|
|
goto error;
|
|
}
|
|
|
|
replace_template_attribute("DISK_TYPE_" + tm_mad, st);
|
|
}
|
|
}
|
|
|
|
st = vatt->vector_value("LN_TARGET");
|
|
|
|
if (check_tm_target_type(st) == -1)
|
|
{
|
|
goto error;
|
|
}
|
|
|
|
replace_template_attribute("LN_TARGET", st);
|
|
|
|
st = vatt->vector_value("CLONE_TARGET");
|
|
|
|
if (check_tm_target_type(st) == -1)
|
|
{
|
|
goto error;
|
|
}
|
|
|
|
replace_template_attribute("CLONE_TARGET", st);
|
|
|
|
st = vatt->vector_value("DRIVER");
|
|
|
|
if (!st.empty())
|
|
{
|
|
replace_template_attribute("DRIVER", st);
|
|
}
|
|
|
|
remove_template_attribute("SHARED");
|
|
}
|
|
|
|
bool orph;
|
|
|
|
if ( vatt->vector_value("ALLOW_ORPHANS", orph) == -1 )
|
|
{
|
|
orph = false;
|
|
}
|
|
|
|
replace_template_attribute("ALLOW_ORPHANS", orph);
|
|
|
|
return 0;
|
|
|
|
error_conf:
|
|
oss << "TM_MAD named \"" << tm_mad << "\" is not defined in oned.conf";
|
|
goto error_common;
|
|
|
|
error:
|
|
oss << "Attribute shared, ln_target or clone_target in TM_MAD_CONF for "
|
|
<< tm_mad << " is missing or has wrong value in oned.conf";
|
|
|
|
error_common:
|
|
error_str = oss.str();
|
|
return -1;
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
int Datastore::set_ds_disk_type(string& s_dt, string& error)
|
|
{
|
|
if (s_dt.empty())
|
|
{
|
|
disk_type = Image::FILE;
|
|
}
|
|
else
|
|
{
|
|
disk_type = Image::str_to_disk_type(s_dt);
|
|
}
|
|
|
|
switch(type)
|
|
{
|
|
case IMAGE_DS:
|
|
switch(disk_type)
|
|
{
|
|
//Valid disk types for Image DS
|
|
case Image::FILE:
|
|
case Image::BLOCK:
|
|
case Image::ISCSI:
|
|
case Image::RBD:
|
|
case Image::GLUSTER:
|
|
case Image::SHEEPDOG:
|
|
break;
|
|
|
|
case Image::CD_ROM:
|
|
case Image::RBD_CDROM:
|
|
case Image::SHEEPDOG_CDROM:
|
|
case Image::GLUSTER_CDROM:
|
|
error = "Invalid DISK_TYPE for an Image Datastore.";
|
|
return -1;
|
|
|
|
case Image::NONE:
|
|
error = "Unknown DISK_TYPE in template.";
|
|
return -1;
|
|
}
|
|
break;
|
|
|
|
case SYSTEM_DS:
|
|
switch(disk_type)
|
|
{
|
|
//Valid disk types for System DS
|
|
case Image::FILE:
|
|
case Image::RBD:
|
|
break;
|
|
|
|
case Image::GLUSTER:
|
|
case Image::SHEEPDOG:
|
|
case Image::BLOCK:
|
|
case Image::ISCSI:
|
|
case Image::CD_ROM:
|
|
case Image::RBD_CDROM:
|
|
case Image::SHEEPDOG_CDROM:
|
|
case Image::GLUSTER_CDROM:
|
|
error = "Invalid DISK_TYPE for a System Datastore.";
|
|
return -1;
|
|
|
|
case Image::NONE:
|
|
error = "Unknown DISK_TYPE in template.";
|
|
return -1;
|
|
}
|
|
break;
|
|
|
|
case FILE_DS:
|
|
disk_type = Image::FILE;
|
|
break;
|
|
}
|
|
|
|
switch(type)
|
|
{
|
|
case IMAGE_DS:
|
|
case SYSTEM_DS:
|
|
add_template_attribute("DISK_TYPE", Image::disk_type_to_str(disk_type));
|
|
break;
|
|
case FILE_DS:
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
int Datastore::insert(SqlDB *db, string& error_str)
|
|
{
|
|
string s_disk_type;
|
|
string s_ds_type;
|
|
string datastore_location;
|
|
|
|
string safe_dirs;
|
|
string restricted_dirs;
|
|
|
|
ostringstream oss;
|
|
|
|
// -------------------------------------------------------------------------
|
|
// Check default datastore attributes
|
|
// -------------------------------------------------------------------------
|
|
|
|
erase_template_attribute("NAME", name);//DatastorePool::allocate checks NAME
|
|
|
|
get_template_attribute("DS_MAD", ds_mad);
|
|
get_template_attribute("TYPE", s_ds_type);
|
|
|
|
type = str_to_type(s_ds_type);
|
|
|
|
if ( type == SYSTEM_DS )
|
|
{
|
|
if ( !ds_mad.empty() )
|
|
{
|
|
goto error_exclusive;
|
|
}
|
|
|
|
ds_mad = "-";
|
|
}
|
|
else if ( ds_mad.empty() == true )
|
|
{
|
|
goto error_ds;
|
|
}
|
|
|
|
if (set_ds_mad(ds_mad, error_str) != 0)
|
|
{
|
|
goto error_common;
|
|
}
|
|
|
|
get_template_attribute("TM_MAD", tm_mad);
|
|
|
|
if ( tm_mad.empty() == true )
|
|
{
|
|
goto error_empty_tm;
|
|
}
|
|
|
|
if (set_tm_mad(tm_mad, error_str) != 0)
|
|
{
|
|
goto error_common;
|
|
}
|
|
|
|
remove_template_attribute("BASE_PATH");
|
|
|
|
Nebula::instance().get_ds_location(base_path);
|
|
|
|
if ( base_path.at(base_path.size()-1) != '/' )
|
|
{
|
|
base_path += "/";
|
|
}
|
|
|
|
oss << base_path << oid;
|
|
|
|
base_path = oss.str();
|
|
|
|
erase_template_attribute("DISK_TYPE", s_disk_type);
|
|
|
|
if (set_ds_disk_type(s_disk_type, error_str) == -1)
|
|
{
|
|
goto error_common;
|
|
}
|
|
|
|
if ( tm_mad.empty() == true )
|
|
{
|
|
goto error_empty_tm;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// Set default SAFE_DIRS & RESTRICTED_DIRS if not set
|
|
//--------------------------------------------------------------------------
|
|
get_template_attribute("SAFE_DIRS", safe_dirs);
|
|
get_template_attribute("RESTRICTED_DIRS", restricted_dirs);
|
|
|
|
if ( safe_dirs.empty() && restricted_dirs.empty() )
|
|
{
|
|
replace_template_attribute("SAFE_DIRS", "/var/tmp");
|
|
replace_template_attribute("RESTRICTED_DIRS", "/");
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// Insert the Datastore
|
|
//--------------------------------------------------------------------------
|
|
return insert_replace(db, false, error_str);
|
|
|
|
error_exclusive:
|
|
error_str = "SYSTEM datastores cannot have DS_MAD defined.";
|
|
goto error_common;
|
|
|
|
error_ds:
|
|
error_str = "No DS_MAD in template.";
|
|
goto error_common;
|
|
|
|
error_empty_tm:
|
|
error_str = "No TM_MAD in template.";
|
|
goto error_common;
|
|
|
|
error_common:
|
|
NebulaLog::log("DATASTORE", Log::ERROR, error_str);
|
|
return -1;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------ */
|
|
/* ------------------------------------------------------------------------ */
|
|
|
|
int Datastore::insert_replace(SqlDB *db, bool replace, string& error_str)
|
|
{
|
|
ostringstream oss;
|
|
|
|
int rc;
|
|
string xml_body;
|
|
|
|
char * sql_name;
|
|
char * sql_xml;
|
|
|
|
// Update the Datastore
|
|
|
|
sql_name = db->escape_str(name.c_str());
|
|
|
|
if ( sql_name == 0 )
|
|
{
|
|
goto error_name;
|
|
}
|
|
|
|
sql_xml = db->escape_str(to_xml(xml_body).c_str());
|
|
|
|
if ( sql_xml == 0 )
|
|
{
|
|
goto error_body;
|
|
}
|
|
|
|
if ( validate_xml(sql_xml) != 0 )
|
|
{
|
|
goto error_xml;
|
|
}
|
|
|
|
if ( replace )
|
|
{
|
|
oss << "REPLACE";
|
|
}
|
|
else
|
|
{
|
|
oss << "INSERT";
|
|
}
|
|
|
|
// Construct the SQL statement to Insert or Replace
|
|
|
|
oss <<" INTO "<<table <<" ("<< db_names <<") VALUES ("
|
|
<< oid << ","
|
|
<< "'" << sql_name << "',"
|
|
<< "'" << sql_xml << "',"
|
|
<< uid << ","
|
|
<< gid << ","
|
|
<< owner_u << ","
|
|
<< group_u << ","
|
|
<< other_u << ")";
|
|
|
|
rc = db->exec_wr(oss);
|
|
|
|
db->free_str(sql_name);
|
|
db->free_str(sql_xml);
|
|
|
|
return rc;
|
|
|
|
error_xml:
|
|
db->free_str(sql_name);
|
|
db->free_str(sql_xml);
|
|
|
|
error_str = "Error transforming the Datastore to XML.";
|
|
|
|
goto error_common;
|
|
|
|
error_body:
|
|
db->free_str(sql_name);
|
|
goto error_generic;
|
|
|
|
error_name:
|
|
goto error_generic;
|
|
|
|
error_generic:
|
|
error_str = "Error inserting Datastore in DB.";
|
|
error_common:
|
|
return -1;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------ */
|
|
/* ------------------------------------------------------------------------ */
|
|
|
|
string& Datastore::to_xml(string& xml) const
|
|
{
|
|
ostringstream oss;
|
|
string clusters_xml;
|
|
string images_xml;
|
|
string template_xml;
|
|
string perms_xml;
|
|
|
|
oss <<
|
|
"<DATASTORE>" <<
|
|
"<ID>" << oid << "</ID>" <<
|
|
"<UID>" << uid << "</UID>" <<
|
|
"<GID>" << gid << "</GID>" <<
|
|
"<UNAME>" << uname << "</UNAME>" <<
|
|
"<GNAME>" << gname << "</GNAME>" <<
|
|
"<NAME>" << name << "</NAME>" <<
|
|
perms_to_xml(perms_xml) <<
|
|
"<DS_MAD>" << one_util::escape_xml(ds_mad) << "</DS_MAD>" <<
|
|
"<TM_MAD>" << one_util::escape_xml(tm_mad) << "</TM_MAD>" <<
|
|
"<BASE_PATH>" << one_util::escape_xml(base_path) << "</BASE_PATH>" <<
|
|
"<TYPE>" << type << "</TYPE>" <<
|
|
"<DISK_TYPE>" << disk_type << "</DISK_TYPE>" <<
|
|
"<STATE>" << state << "</STATE>" <<
|
|
Clusterable::to_xml(clusters_xml) <<
|
|
"<TOTAL_MB>" << total_mb << "</TOTAL_MB>" <<
|
|
"<FREE_MB>" << free_mb << "</FREE_MB>" <<
|
|
"<USED_MB>" << used_mb << "</USED_MB>" <<
|
|
images.to_xml(images_xml) <<
|
|
obj_template->to_xml(template_xml) <<
|
|
"</DATASTORE>";
|
|
|
|
xml = oss.str();
|
|
|
|
return xml;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------ */
|
|
/* ------------------------------------------------------------------------ */
|
|
|
|
int Datastore::from_xml(const string& xml)
|
|
{
|
|
int rc = 0;
|
|
int int_disk_type;
|
|
int int_ds_type;
|
|
int int_state;
|
|
vector<xmlNodePtr> content;
|
|
|
|
ostringstream oss;
|
|
|
|
// Initialize the internal XML object
|
|
update_from_str(xml);
|
|
|
|
// Get class base attributes
|
|
rc += xpath(oid, "/DATASTORE/ID", -1);
|
|
rc += xpath(uid, "/DATASTORE/UID", -1);
|
|
rc += xpath(gid, "/DATASTORE/GID", -1);
|
|
rc += xpath(uname, "/DATASTORE/UNAME", "not_found");
|
|
rc += xpath(gname, "/DATASTORE/GNAME", "not_found");
|
|
rc += xpath(name, "/DATASTORE/NAME", "not_found");
|
|
rc += xpath(ds_mad, "/DATASTORE/DS_MAD", "not_found");
|
|
rc += xpath(tm_mad, "/DATASTORE/TM_MAD", "not_found");
|
|
rc += xpath(int_ds_type, "/DATASTORE/TYPE", -1);
|
|
rc += xpath(int_disk_type,"/DATASTORE/DISK_TYPE", -1);
|
|
rc += xpath(int_state, "/DATASTORE/STATE", 0);
|
|
|
|
rc += xpath<long long>(total_mb,"/DATASTORE/TOTAL_MB",0);
|
|
rc += xpath<long long>(free_mb, "/DATASTORE/FREE_MB", 0);
|
|
rc += xpath<long long>(used_mb, "/DATASTORE/USED_MB", 0);
|
|
|
|
// Permissions
|
|
rc += perms_from_xml();
|
|
|
|
disk_type = static_cast<Image::DiskType>(int_disk_type);
|
|
type = static_cast<Datastore::DatastoreType>(int_ds_type);
|
|
state = static_cast<DatastoreState>(int_state);
|
|
|
|
// Set of Image IDs
|
|
rc += images.from_xml(this, "/DATASTORE/");
|
|
|
|
// Set of cluster IDs
|
|
rc += Clusterable::from_xml(this, "/DATASTORE/");
|
|
|
|
// Get associated classes
|
|
ObjectXML::get_nodes("/DATASTORE/TEMPLATE", content);
|
|
|
|
if (content.empty())
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
rc += obj_template->from_xml_node(content[0]);
|
|
|
|
ObjectXML::free_nodes(content);
|
|
|
|
Nebula::instance().get_ds_location(base_path);
|
|
|
|
if ( base_path.at(base_path.size()-1) != '/' )
|
|
{
|
|
base_path += "/";
|
|
}
|
|
|
|
oss << base_path << oid;
|
|
|
|
base_path = oss.str();
|
|
|
|
if (rc != 0)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------ */
|
|
/* ------------------------------------------------------------------------ */
|
|
|
|
int Datastore::post_update_template(string& error_str)
|
|
{
|
|
string new_ds_mad;
|
|
string new_tm_mad;
|
|
string s_ds_type;
|
|
string new_disk_type;
|
|
string new_base_path;
|
|
string vcenter_password;
|
|
|
|
DatastoreType new_ds_type;
|
|
|
|
DatastoreType old_ds_type = type;
|
|
Image::DiskType old_disk_type = disk_type;
|
|
string old_tm_mad = tm_mad;
|
|
string old_ds_mad = ds_mad;
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
/* Set the TYPE of the Datastore (class & template) */
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
get_template_attribute("TYPE", s_ds_type);
|
|
|
|
if (!s_ds_type.empty())
|
|
{
|
|
new_ds_type = str_to_type(s_ds_type);
|
|
}
|
|
else //No TYPE in the new Datastore template
|
|
{
|
|
new_ds_type = type;
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
/* Set the TYPE of the Datastore (class & template) */
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
if ( oid == DatastorePool::SYSTEM_DS_ID )
|
|
{
|
|
type = SYSTEM_DS;
|
|
}
|
|
else
|
|
{
|
|
type = new_ds_type;
|
|
}
|
|
|
|
replace_template_attribute("TYPE", type_to_str(type));
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
/* Set the DISK_TYPE (class & template) */
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
erase_template_attribute("DISK_TYPE", new_disk_type);
|
|
|
|
if (!new_disk_type.empty())
|
|
{
|
|
if ( set_ds_disk_type(new_disk_type, error_str) == -1 )
|
|
{
|
|
//Rollback variable changes
|
|
type = old_ds_type;
|
|
disk_type = old_disk_type;
|
|
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
/* Encrypt VCENTER_PASSWORD attribute */
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
get_template_attribute("VCENTER_PASSWORD", vcenter_password);
|
|
|
|
if (!vcenter_password.empty() && vcenter_password.size() <= 22)
|
|
{
|
|
erase_template_attribute("VCENTER_PASSWORD", vcenter_password);
|
|
|
|
Nebula& nd = Nebula::instance();
|
|
string one_key;
|
|
string * encrypted;
|
|
|
|
nd.get_configuration_attribute("ONE_KEY", one_key);
|
|
|
|
if (!one_key.empty())
|
|
{
|
|
encrypted = one_util::aes256cbc_encrypt(vcenter_password, one_key);
|
|
|
|
add_template_attribute("VCENTER_PASSWORD", *encrypted);
|
|
|
|
delete encrypted;
|
|
}
|
|
else
|
|
{
|
|
add_template_attribute("VCENTER_PASSWORD", vcenter_password);
|
|
}
|
|
}
|
|
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
/* Set the TM_MAD of the Datastore (class & template) */
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
get_template_attribute("TM_MAD", new_tm_mad);
|
|
|
|
if ( !new_tm_mad.empty() )
|
|
{
|
|
// System DS are monitored by the TM mad, reset information
|
|
if ( type == SYSTEM_DS && new_tm_mad != tm_mad )
|
|
{
|
|
update_monitor(0, 0, 0);
|
|
}
|
|
|
|
if (set_tm_mad(new_tm_mad, error_str) != 0)
|
|
{
|
|
type = old_ds_type;
|
|
disk_type = old_disk_type;
|
|
|
|
return -1;
|
|
}
|
|
|
|
tm_mad = new_tm_mad;
|
|
}
|
|
else
|
|
{
|
|
replace_template_attribute("TM_MAD", tm_mad);
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
/* Set the DS_MAD of the Datastore (class & template) */
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
get_template_attribute("DS_MAD", new_ds_mad);
|
|
|
|
if ( type == SYSTEM_DS )
|
|
{
|
|
ds_mad = "-";
|
|
|
|
remove_template_attribute("DS_MAD");
|
|
}
|
|
else
|
|
{
|
|
if ( new_ds_mad.empty() )
|
|
{
|
|
replace_template_attribute("DS_MAD", ds_mad);
|
|
}
|
|
else if ( new_ds_mad != ds_mad)
|
|
{
|
|
ds_mad = new_ds_mad;
|
|
|
|
// DS are monitored by the DS mad, reset information
|
|
update_monitor(0, 0, 0);
|
|
}
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
/* Verify that the template has the required attributees */
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
if ( set_ds_mad(ds_mad, error_str) != 0 )
|
|
{
|
|
type = old_ds_type;
|
|
disk_type = old_disk_type;
|
|
tm_mad = old_tm_mad;
|
|
ds_mad = old_ds_mad;
|
|
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------ */
|
|
/* ------------------------------------------------------------------------ */
|
|
|
|
bool Datastore::get_avail_mb(long long &avail)
|
|
{
|
|
long long limit_mb;
|
|
long long free_limited;
|
|
bool check;
|
|
|
|
avail = free_mb;
|
|
|
|
if (get_template_attribute("LIMIT_MB", limit_mb))
|
|
{
|
|
free_limited = limit_mb - used_mb;
|
|
|
|
if (free_limited < free_mb)
|
|
{
|
|
avail = free_limited;
|
|
}
|
|
}
|
|
|
|
if (avail < 0)
|
|
{
|
|
avail = 0;
|
|
}
|
|
|
|
if (!get_template_attribute("DATASTORE_CAPACITY_CHECK", check))
|
|
{
|
|
Nebula& nd = Nebula::instance();
|
|
|
|
nd.get_configuration_attribute("DATASTORE_CAPACITY_CHECK", check);
|
|
}
|
|
|
|
return check;
|
|
}
|
|
|
|
/* ------------------------------------------------------------------------ */
|
|
/* ------------------------------------------------------------------------ */
|
|
|
|
bool Datastore::is_persistent_only()
|
|
{
|
|
int rc;
|
|
bool persistent_only = false;
|
|
|
|
const VectorAttribute* vatt;
|
|
|
|
rc = Nebula::instance().get_ds_conf_attribute(ds_mad, vatt);
|
|
|
|
if ( rc != 0 )
|
|
{
|
|
// No DS_MAD_CONF is available for this DS_MAD.
|
|
// Assuming this DS is not PERSISTENT_ONLY
|
|
return false;
|
|
}
|
|
|
|
vatt->vector_value("PERSISTENT_ONLY", persistent_only);
|
|
|
|
return persistent_only;
|
|
};
|