1
0
mirror of https://github.com/OpenNebula/one.git synced 2025-03-22 18:50:08 +03:00

feature #1222: Simplfy TM functions, fix wrong ds ids. Remove size from clone/ln

This commit is contained in:
Ruben S. Montero 2012-04-18 16:48:56 +02:00
parent b76e5cd07c
commit 95b9d44a3c

View File

@ -227,11 +227,19 @@ void TransferManager::prolog_action(int vid)
int context_result;
// ------------------------------------------------------------------------
// -------------------------------------------------------------------------
// Setup & Transfer script
// ------------------------------------------------------------------------
// -------------------------------------------------------------------------
system_tm_mad = nd.get_system_ds_tm_mad();
tm_md = get();
if ( tm_md == 0 || system_tm_mad.empty() )
{
NebulaLog::log("TM", Log::ERROR, "prolog, error getting drivers.");
(nd.get_lcm())->trigger(LifeCycleManager::PROLOG_FAILURE,vid);
return;
}
vm = vmpool->get(vid,true);
@ -245,13 +253,6 @@ void TransferManager::prolog_action(int vid)
goto error_history;
}
tm_md = get();
if ( tm_md == 0 )
{
goto error_driver;
}
xfr_name = vm->get_transfer_file() + ".prolog";
xfr.open(xfr_name.c_str(), ios::out | ios::trunc);
@ -260,13 +261,12 @@ void TransferManager::prolog_action(int vid)
goto error_file;
}
// ------------------------------------------------------------------------
// Swap and image Commands
// ------------------------------------------------------------------------
// -------------------------------------------------------------------------
// Image Transfer Commands
// -------------------------------------------------------------------------
num = vm->get_template_attribute("DISK",attrs);
for (int i=0; i < num ;i++, source="", type="", clon="",tm_mad="",ds_id="-")
for (int i=0; i < num; i++)
{
disk = dynamic_cast<const VectorAttribute *>(attrs[i]);
@ -277,19 +277,8 @@ void TransferManager::prolog_action(int vid)
type = disk->vector_value("TYPE");
if ( type.empty() == false)
{
transform(type.begin(),type.end(),type.begin(),
(int(*)(int))toupper);
}
ds_id = disk->vector_value("DATASTORE_ID");
if ( ds_id.empty() )
{
ds_id = "-";
}
transform(type.begin(),type.end(),type.begin(),(int(*)(int))toupper);
if ( type == "SWAP" )
{
// -----------------------------------------------------------------
@ -297,20 +286,20 @@ void TransferManager::prolog_action(int vid)
// -----------------------------------------------------------------
size = disk->vector_value("SIZE");
if (size.empty()==true)
if ( size.empty() )
{
vm->log("TM",Log::WARNING,"No size in swap image, skipping");
continue;
}
//MKSWAP tm_mad size host:remote_system_dir/disk.i
//MKSWAP tm_mad size host:remote_system_dir/disk.i vmid dsid(=0)
xfr << "MKSWAP "
<< system_tm_mad << " "
<< size << " "
<< vm->get_hostname() << ":"
<< vm->get_remote_system_dir() << "/disk." << i << " "
<< vm->get_oid() << " "
<< ds_id << endl;
<< "0" << endl;
}
else if ( type == "FS" )
{
@ -320,13 +309,13 @@ void TransferManager::prolog_action(int vid)
size = disk->vector_value("SIZE");
format = disk->vector_value("FORMAT");
if ( size.empty() || format.empty())
if ( size.empty() || format.empty() )
{
vm->log("TM",Log::WARNING,"No size or format in plain FS image,"
" skipping");
vm->log("TM",Log::WARNING, "No size or format in FS, skipping");
continue;
}
//MKIMAGE tm_mad size format host:remote_system_dir/disk.i
//MKIMAGE tm_mad size format host:remote_system_dir/disk.i vmid dsid(=0)
xfr << "MKIMAGE "
<< system_tm_mad << " "
<< size << " "
@ -334,34 +323,33 @@ void TransferManager::prolog_action(int vid)
<< vm->get_hostname() << ":"
<< vm->get_remote_system_dir() << "/disk." << i << " "
<< vm->get_oid() << " "
<< ds_id << endl;
<< "0" << endl;
}
else
{
// -----------------------------------------------------------------
// Get transfer attributes & check errors
// -----------------------------------------------------------------
tm_mad = disk->vector_value("TM_MAD");
ds_id = disk->vector_value("DATASTORE_ID");
source = disk->vector_value("SOURCE");
clon = disk->vector_value("CLONE");
if ( tm_mad.empty() )
if ( source.empty() ||
tm_mad.empty() ||
ds_id.empty() ||
clon.empty() )
{
goto error_tm_mad;
goto error_attributes;
}
transform(clon.begin(),clon.end(),clon.begin(),(int(*)(int))toupper);
// -----------------------------------------------------------------
// CLONE or LINK disk images
// -----------------------------------------------------------------
clon = disk->vector_value("CLONE");
size = disk->vector_value("SIZE");
if ( clon.empty() == true )
{
clon = "YES"; //Clone by default
}
else
{
transform(clon.begin(),clon.end(),clon.begin(),
(int(*)(int))toupper);
}
// <CLONE|LN> tm_mad fe:SOURCE host:remote_system_ds/disk.i size
// <CLONE|LN> tm_mad fe:SOURCE host:remote_system_ds/disk.i vmid dsid
if (clon == "YES")
{
xfr << "CLONE ";
@ -373,16 +361,6 @@ void TransferManager::prolog_action(int vid)
xfr << tm_mad << " ";
// -----------------------------------------------------------------
// Get the disk image, and set source URL
// -----------------------------------------------------------------
source = disk->vector_value("SOURCE");
if ( source.empty() )
{
goto error_empty_disk;
}
if ( source.find(":") == string::npos ) //Regular file
{
xfr << nd.get_nebula_hostname() << ":" << source << " ";
@ -393,21 +371,15 @@ void TransferManager::prolog_action(int vid)
}
xfr << vm->get_hostname() << ":"
<< vm->get_remote_system_dir() << "/disk." << i;
if (!size.empty()) //Add size for dev based disks
{
xfr << " " << size;
}
xfr << " " << vm->get_oid() << " " << ds_id << endl;
<< vm->get_remote_system_dir() << "/disk." << i << " "
<< vm->get_oid() << " "
<< ds_id << endl;
}
}
// ------------------------------------------------------------------------
// -------------------------------------------------------------------------
// Generate context file (There are 0...num-1 disks, constext is disk.num)
// ------------------------------------------------------------------------
// -------------------------------------------------------------------------
context_result = vm->generate_context(files);
if ( context_result == -1 )
@ -417,7 +389,7 @@ void TransferManager::prolog_action(int vid)
if ( context_result )
{
//CONTEXT tm_mad files hostname:remote_system_dir/disk.i
//CONTEXT tm_mad files hostname:remote_system_dir/disk.i vmid dsid(=0)
xfr << "CONTEXT "
<< system_tm_mad << " "
<< vm->get_context_file() << " ";
@ -428,8 +400,9 @@ void TransferManager::prolog_action(int vid)
}
xfr << vm->get_hostname() << ":"
<< vm->get_remote_system_dir() << "/disk." << num
<< " " << vm->get_oid() << " -" << endl;
<< vm->get_remote_system_dir() << "/disk." << num << " "
<< vm->get_oid() << " "
<< "0" << endl;
}
xfr.close();
@ -440,11 +413,6 @@ void TransferManager::prolog_action(int vid)
return;
error_context:
os.str("");
os << "prolog, could not write context file for VM " << vid;
goto error_common;
error_history:
os.str("");
os << "prolog, VM " << vid << " has no history";
@ -455,20 +423,20 @@ error_file:
os << "prolog, could not open file: " << xfr_name;
goto error_common;
error_driver:
error_attributes:
os.str("");
os << "prolog, error getting Transfer Manager driver.";
os << "prolog, missing DISK mandatory attributes "
<< "(SOURCE, TM_MAD, CLONE, DATASTORE_ID) for VM " << vid;
xfr.close();
goto error_common;
error_tm_mad:
error_context:
os.str("");
os << "prolog, undefined TM_MAD for disk image in VM template";
xfr.close();
os << "prolog, could not write context file for VM " << vid;
error_empty_disk:
os.str("");
os << "prolog, undefined source disk image in VM template";
xfr.close();
goto error_common;
error_common:
(nd.get_lcm())->trigger(LifeCycleManager::PROLOG_FAILURE,vid);
@ -500,11 +468,19 @@ void TransferManager::prolog_migr_action(int vid)
const TransferManagerDriver * tm_md;
// ------------------------------------------------------------------------
// -------------------------------------------------------------------------
// Setup & Transfer script
// ------------------------------------------------------------------------
// -------------------------------------------------------------------------
system_tm_mad = nd.get_system_ds_tm_mad();
tm_md = get();
if ( tm_md == 0 || system_tm_mad.empty() )
{
NebulaLog::log("TM", Log::ERROR, "prolog_migr, error getting drivers.");
(nd.get_lcm())->trigger(LifeCycleManager::PROLOG_FAILURE,vid);
return;
}
vm = vmpool->get(vid,true);
@ -518,13 +494,6 @@ void TransferManager::prolog_migr_action(int vid)
goto error_history;
}
tm_md = get();
if ( tm_md == 0 )
{
goto error_driver;
}
xfr_name = vm->get_transfer_file() + ".migrate";
xfr.open(xfr_name.c_str(), ios::out | ios::trunc);
@ -539,7 +508,7 @@ void TransferManager::prolog_migr_action(int vid)
num = vm->get_template_attribute("DISK",attrs);
for (int i=0 ; i < num ; i++, tm_mad="", ds_id="-")
for (int i=0 ; i < num ; i++)
{
disk = dynamic_cast<const VectorAttribute *>(attrs[i]);
@ -549,20 +518,14 @@ void TransferManager::prolog_migr_action(int vid)
}
tm_mad = disk->vector_value("TM_MAD");
ds_id = disk->vector_value("DATASTORE_ID");
if ( tm_mad.empty() )
if ( tm_mad.empty() || ds_id.empty() )
{
continue;
}
ds_id = disk->vector_value("DATASTORE_ID");
if ( ds_id.empty() )
{
ds_id = "-";
}
//MV tm_mad prev_host:remote_system_dir/disk.i host:remote_system_dir/disk.i
//MV tm_mad prev_host:remote_system_dir/disk.i host:remote_system_dir/disk.i vmid dsid
xfr << "MV "
<< tm_mad << " "
<< vm->get_previous_hostname() << ":"
@ -573,14 +536,15 @@ void TransferManager::prolog_migr_action(int vid)
<< ds_id << endl;
}
//MV tm_mad prev_host:remote_system_dir host:remote_system_dir
//MV tm_mad prev_host:remote_system_dir host:remote_system_dir VMID 0
xfr << "MV "
<< system_tm_mad << " "
<< vm->get_previous_hostname() << ":"
<< vm->get_remote_system_dir() << " "
<< vm->get_hostname() << ":"
<< vm->get_remote_system_dir() << " "
<< vm->get_oid() << " -" << endl;
<< vm->get_oid() << " "
<< "0" << endl;
xfr.close();
@ -600,10 +564,6 @@ error_file:
os << "prolog_migr, could not open file: " << xfr_name;
goto error_common;
error_driver:
os.str("");
os << "prolog_migr, error getting Transfer Manager driver.";
error_common:
(nd.get_lcm())->trigger(LifeCycleManager::PROLOG_FAILURE,vid);
vm->log("TM", Log::ERROR, os);
@ -634,11 +594,19 @@ void TransferManager::prolog_resume_action(int vid)
const TransferManagerDriver * tm_md;
// ------------------------------------------------------------------------
// -------------------------------------------------------------------------
// Setup & Transfer script
// ------------------------------------------------------------------------
// -------------------------------------------------------------------------
system_tm_mad = nd.get_system_ds_tm_mad();
tm_md = get();
if ( tm_md == 0 || system_tm_mad.empty() )
{
NebulaLog::log("TM", Log::ERROR, "prolog_resume, error getting drivers.");
(nd.get_lcm())->trigger(LifeCycleManager::PROLOG_FAILURE,vid);
return;
}
vm = vmpool->get(vid,true);
@ -652,13 +620,6 @@ void TransferManager::prolog_resume_action(int vid)
goto error_history;
}
tm_md = get();
if ( tm_md == 0 )
{
goto error_driver;
}
xfr_name = vm->get_transfer_file() + ".resume";
xfr.open(xfr_name.c_str(), ios::out | ios::trunc);
@ -672,7 +633,7 @@ void TransferManager::prolog_resume_action(int vid)
// ------------------------------------------------------------------------
num = vm->get_template_attribute("DISK",attrs);
for (int i=0 ; i < num ; i++, tm_mad="", ds_id="-")
for (int i=0 ; i < num ; i++)
{
disk = dynamic_cast<const VectorAttribute *>(attrs[i]);
@ -682,20 +643,14 @@ void TransferManager::prolog_resume_action(int vid)
}
tm_mad = disk->vector_value("TM_MAD");
ds_id = disk->vector_value("DATASTORE_ID");
if ( tm_mad.empty() )
if ( tm_mad.empty() || ds_id.empty() )
{
continue;
}
ds_id = disk->vector_value("DATASTORE_ID");
if ( ds_id.empty() )
{
ds_id = "-";
}
//MV tm_mad fe:system_dir/disk.i host:remote_system_dir/disk.i
//MV tm_mad fe:system_dir/disk.i host:remote_system_dir/disk.i vmid dsid
xfr << "MV "
<< tm_mad << " "
<< nd.get_nebula_hostname() << ":"
@ -706,12 +661,13 @@ void TransferManager::prolog_resume_action(int vid)
<< ds_id << endl;
}
//MV tm_mad fe:system_dir host:remote_system_dir
//MV tm_mad fe:system_dir host:remote_system_dir vmid 0
xfr << "MV "
<< system_tm_mad << " "
<< nd.get_nebula_hostname() << ":"<< vm->get_system_dir() << " "
<< vm->get_hostname() << ":" << vm->get_remote_system_dir()<< " "
<< vm->get_oid() << " -" << endl;
<< vm->get_oid() << " "
<< "0" << endl;
xfr.close();
@ -731,10 +687,6 @@ error_file:
os << "prolog_resume, could not open file: " << xfr_name;
goto error_common;
error_driver:
os.str("");
os << "prolog_resume, error getting Transfer Manager driver.";
error_common:
(nd.get_lcm())->trigger(LifeCycleManager::PROLOG_FAILURE,vid);
vm->log("TM", Log::ERROR, os);
@ -769,8 +721,16 @@ void TransferManager::epilog_action(int vid)
// ------------------------------------------------------------------------
// Setup & Transfer script
// ------------------------------------------------------------------------
system_tm_mad = nd.get_system_ds_tm_mad();
tm_md = get();
if ( tm_md == 0 || system_tm_mad.empty() )
{
NebulaLog::log("TM", Log::ERROR, "epilog, error getting drivers.");
(nd.get_lcm())->trigger(LifeCycleManager::EPILOG_FAILURE,vid);
return;
}
vm = vmpool->get(vid,true);
@ -784,13 +744,6 @@ void TransferManager::epilog_action(int vid)
goto error_history;
}
tm_md = get();
if ( tm_md == 0 )
{
goto error_driver;
}
xfr_name = vm->get_transfer_file() + ".epilog";
xfr.open(xfr_name.c_str(), ios::out | ios::trunc);
@ -799,13 +752,12 @@ void TransferManager::epilog_action(int vid)
goto error_file;
}
// ------------------------------------------------------------------------
// -------------------------------------------------------------------------
// copy back VM image (DISK with SAVE="yes")
// ------------------------------------------------------------------------
// -------------------------------------------------------------------------
num = vm->get_template_attribute("DISK",attrs);
for (int i=0; i < num; i++, save="", ds_id="-")
for (int i=0; i < num; i++)
{
disk = dynamic_cast<const VectorAttribute *>(attrs[i]);
@ -814,44 +766,37 @@ void TransferManager::epilog_action(int vid)
continue;
}
save = disk->vector_value("SAVE");
save = disk->vector_value("SAVE");
ds_id = disk->vector_value("DATASTORE_ID");
tm_mad = disk->vector_value("TM_MAD");
if ( save.empty() == true)
if ( save.empty() || ds_id.empty() || tm_mad.empty() )
{
continue;
}
ds_id = disk->vector_value("DATASTORE_ID");
if ( ds_id.empty() )
{
ds_id = "-";
}
transform(save.begin(),save.end(),save.begin(),(int(*)(int))toupper);
tm_mad = disk->vector_value("TM_MAD");
if ( save == "YES" ) //TODO SAVE_SOURCE
if ( save == "YES" )
{
string source;
string save_source;
string source;
string save_source;
source = disk->vector_value("SOURCE");
save_source = disk->vector_value("SAVE_AS_SOURCE");
if ( source.empty() && save_source.empty() )
if (source.empty() && save_source.empty())
{
vm->log("TM", Log::ERROR, "No SOURCE to save disk image");
continue;
}
if (!save_source.empty()) //Use the save as source instead
if (!save_source.empty())//Use the save_as_source instead
{
source = save_source;
}
//MVDS tm_mad hostname:remote_system_dir/disk.0 <fe:SOURCE|SOURCE>
//MVDS tm_mad hostname:remote_system_dir/disk.0 <fe:SOURCE|SOURCE> vmid dsid
xfr << "MVDS "
<< tm_mad << " "
<< vm->get_hostname() << ":"
@ -860,9 +805,9 @@ void TransferManager::epilog_action(int vid)
<< vm->get_oid() << " "
<< ds_id << endl;
}
else if ( !tm_mad.empty() ) //No saving disk and no system_ds disk
else //No saving disk
{
//DELETE tm_mad hostname:remote_system_dir/disk.i
//DELETE tm_mad hostname:remote_system_dir/disk.i vmid ds_id
xfr << "DELETE "
<< tm_mad << " "
<< vm->get_hostname() << ":"
@ -872,11 +817,12 @@ void TransferManager::epilog_action(int vid)
}
}
//DELETE system_tm_mad hostname:remote_system_dir
//DELETE system_tm_mad hostname:remote_system_dir vmid ds_id
xfr << "DELETE "
<< system_tm_mad << " "
<< vm->get_hostname() << ":" << vm->get_remote_system_dir() << " "
<< vm->get_oid() << " -" << endl;
<< vm->get_oid() << " "
<< "0" << endl;
xfr.close();
@ -896,10 +842,6 @@ error_file:
os << "epilog, could not open file: " << xfr_name;
goto error_common;
error_driver:
os.str("");
os << "epilog, error getting Transfer Manager driver.";
error_common:
(nd.get_lcm())->trigger(LifeCycleManager::EPILOG_FAILURE,vid);
vm->log("TM", Log::ERROR, os);
@ -933,6 +875,15 @@ void TransferManager::epilog_stop_action(int vid)
// Setup & Transfer script
// ------------------------------------------------------------------------
system_tm_mad = nd.get_system_ds_tm_mad();
tm_md = get();
if ( tm_md == 0 || system_tm_mad.empty() )
{
NebulaLog::log("TM", Log::ERROR, "epilog_stop, error getting drivers.");
(nd.get_lcm())->trigger(LifeCycleManager::EPILOG_FAILURE,vid);
return;
}
vm = vmpool->get(vid,true);
@ -946,13 +897,6 @@ void TransferManager::epilog_stop_action(int vid)
goto error_history;
}
tm_md = get();
if ( tm_md == 0 )
{
goto error_driver;
}
xfr_name = vm->get_transfer_file() + ".stop";
xfr.open(xfr_name.c_str(), ios::out | ios::trunc);
@ -966,7 +910,7 @@ void TransferManager::epilog_stop_action(int vid)
// ------------------------------------------------------------------------
num = vm->get_template_attribute("DISK",attrs);
for (int i=0 ; i < num ; i++, tm_mad="", ds_id="-")
for (int i=0 ; i < num ; i++)
{
disk = dynamic_cast<const VectorAttribute *>(attrs[i]);
@ -976,20 +920,14 @@ void TransferManager::epilog_stop_action(int vid)
}
tm_mad = disk->vector_value("TM_MAD");
ds_id = disk->vector_value("DATASTORE_ID");
if ( tm_mad.empty() )
if (tm_mad.empty() || ds_id.empty())
{
continue;
}
ds_id = disk->vector_value("DATASTORE_ID");
if ( ds_id.empty() )
{
ds_id = "-";
}
//MV tm_mad host:remote_system_dir/disk.i fe:system_dir/disk.i
//MV tm_mad host:remote_system_dir/disk.i fe:system_dir/disk.i vmid dsid
xfr << "MV "
<< tm_mad << " "
<< vm->get_hostname() << ":"
@ -1005,7 +943,8 @@ void TransferManager::epilog_stop_action(int vid)
<< system_tm_mad << " "
<< vm->get_hostname() << ":" << vm->get_remote_system_dir() << " "
<< nd.get_nebula_hostname() << ":" << vm->get_system_dir() << " "
<< vm->get_oid() << " -" << endl;
<< vm->get_oid() << " "
<< "0" << endl;
xfr.close();
@ -1025,10 +964,6 @@ error_file:
os << "epilog_stop, could not open file: " << xfr_name;
goto error_common;
error_driver:
os.str("");
os << "epilog_stop, error getting Transfer Manager driver.";
error_common:
(nd.get_lcm())->trigger(LifeCycleManager::EPILOG_FAILURE,vid);
vm->log("TM", Log::ERROR, os);
@ -1063,6 +998,15 @@ void TransferManager::epilog_delete_action(int vid)
// Setup & Transfer script
// ------------------------------------------------------------------------
system_tm_mad = nd.get_system_ds_tm_mad();
tm_md = get();
if ( tm_md == 0 || system_tm_mad.empty() )
{
NebulaLog::log("TM", Log::ERROR, "epilog_delete, error getting drivers.");
(nd.get_lcm())->trigger(LifeCycleManager::EPILOG_FAILURE,vid);
return;
}
vm = vmpool->get(vid,true);
@ -1075,13 +1019,6 @@ void TransferManager::epilog_delete_action(int vid)
{
goto error_history;
}
tm_md = get();
if ( tm_md == 0 )
{
goto error_driver;
}
xfr_name = vm->get_transfer_file() + ".delete";
xfr.open(xfr_name.c_str(), ios::out | ios::trunc);
@ -1096,7 +1033,7 @@ void TransferManager::epilog_delete_action(int vid)
// -------------------------------------------------------------------------
num = vm->get_template_attribute("DISK",attrs);
for (int i=0 ; i < num ; i++, tm_mad="", ds_id="-")
for (int i=0 ; i < num ; i++)
{
disk = dynamic_cast<const VectorAttribute *>(attrs[i]);
@ -1106,20 +1043,14 @@ void TransferManager::epilog_delete_action(int vid)
}
tm_mad = disk->vector_value("TM_MAD");
ds_id = disk->vector_value("DATASTORE_ID");
if ( tm_mad.empty() )
if ( tm_mad.empty() || ds_id.empty() )
{
continue;
}
ds_id = disk->vector_value("DATASTORE_ID");
if ( ds_id.empty() )
{
ds_id = "-";
}
//DELETE tm_mad host:remote_system_dir/disk.i
//DELETE tm_mad host:remote_system_dir/disk.i vmid dsid
xfr << "DELETE "
<< tm_mad << " "
<< vm->get_hostname() << ":"
@ -1128,11 +1059,12 @@ void TransferManager::epilog_delete_action(int vid)
<< ds_id << endl;
}
//DELETE system_tm_mad hostname:remote_system_dir
//DELETE system_tm_mad hostname:remote_system_dir vmid dsid(=0)
xfr << "DELETE "
<< system_tm_mad << " "
<< vm->get_hostname() <<":"<< vm->get_remote_system_dir() << " "
<< vm->get_oid() << " -";
<< vm->get_oid() << " "
<< "0";
xfr.close();
@ -1154,12 +1086,6 @@ error_file:
<< ":" << vm->get_remote_system_dir();
goto error_common;
error_driver:
os.str("");
os << "epilog_delete, error getting driver Transfer Manager driver.";
os << ". You may need to manually clean " << vm->get_hostname()
<< ":" << vm->get_remote_system_dir();
error_common:
vm->log("TM", Log::ERROR, os);
vm->unlock();
@ -1191,8 +1117,16 @@ void TransferManager::epilog_delete_previous_action(int vid)
// ------------------------------------------------------------------------
// Setup & Transfer script
// ------------------------------------------------------------------------
system_tm_mad = nd.get_system_ds_tm_mad();
tm_md = get();
if ( tm_md == 0 || system_tm_mad.empty() )
{
NebulaLog::log("TM", Log::ERROR, "epilog_delete, error getting drivers.");
(nd.get_lcm())->trigger(LifeCycleManager::EPILOG_FAILURE,vid);
return;
}
vm = vmpool->get(vid,true);
@ -1206,13 +1140,6 @@ void TransferManager::epilog_delete_previous_action(int vid)
goto error_history;
}
tm_md = get();
if ( tm_md == 0 )
{
goto error_driver;
}
xfr_name = vm->get_transfer_file() + ".delete_prev";
xfr.open(xfr_name.c_str(),ios::out | ios::trunc);
@ -1226,7 +1153,7 @@ void TransferManager::epilog_delete_previous_action(int vid)
// ------------------------------------------------------------------------
num = vm->get_template_attribute("DISK",attrs);
for (int i=0 ; i < num ; i++, tm_mad="", ds_id="-")
for (int i=0 ; i < num ; i++)
{
disk = dynamic_cast<const VectorAttribute *>(attrs[i]);
@ -1236,20 +1163,14 @@ void TransferManager::epilog_delete_previous_action(int vid)
}
tm_mad = disk->vector_value("TM_MAD");
ds_id = disk->vector_value("DATASTORE_ID");
if ( tm_mad.empty() )
if (tm_mad.empty() || ds_id.empty())
{
continue;
}
ds_id = disk->vector_value("DATASTORE_ID");
if ( ds_id.empty() )
{
ds_id = "-";
}
//DELETE tm_mad prev_host:remote_system_dir/disk.i
//DELETE tm_mad prev_host:remote_system_dir/disk.i vmid ds_id
xfr << "DELETE "
<< tm_mad << " "
<< vm->get_previous_hostname() << ":"
@ -1258,11 +1179,12 @@ void TransferManager::epilog_delete_previous_action(int vid)
<< ds_id << endl;
}
//DELTE system_tm_mad prev_host:remote_system_dir
//DELTE system_tm_mad prev_host:remote_system_dir vmid ds_id(=0)
xfr << "DELETE "
<< system_tm_mad << " "
<< vm->get_previous_hostname() <<":"<< vm->get_remote_system_dir()
<< " " << vm->get_oid() << " -" << endl;
<< " " << vm->get_oid() << " "
<< "0" << endl;
xfr.close();
@ -1284,12 +1206,6 @@ error_file:
<< ":" << vm->get_remote_system_dir();
goto error_common;
error_driver:
os.str("");
os << "epilog_delete, error getting driver Transfer Manager driver.";
os << ". You may need to manually clean " << vm->get_previous_hostname()
<< ":" << vm->get_remote_system_dir();
error_common:
vm->log("TM", Log::ERROR, os);
vm->unlock();
@ -1313,6 +1229,12 @@ void TransferManager::driver_cancel_action(int vid)
// ------------------------------------------------------------------------
// Get the Driver for this host
// ------------------------------------------------------------------------
tm_md = get();
if ( tm_md == 0 )
{
return;
}
vm = vmpool->get(vid,true);
@ -1321,13 +1243,6 @@ void TransferManager::driver_cancel_action(int vid)
return;
}
tm_md = get();
if ( tm_md == 0 )
{
goto error_driver;
}
// ------------------------------------------------------------------------
// Cancel the current operation
// ------------------------------------------------------------------------
@ -1336,15 +1251,6 @@ void TransferManager::driver_cancel_action(int vid)
vm->unlock();
return;
error_driver:
os.str("");
os << "driver_cancel, error getting driver Transfer Manager driver.";
vm->log("TM", Log::ERROR, os);
vm->unlock();
return;
}