shaba/one
1
0
Fork 0
mirror of https://github.com/OpenNebula/one.git synced 2024-12-24 21:34:01 +03:00
Code Releases Wiki Activity

Feature #3782: Minor fixes to oned code

Browse Source
This commit is contained in:
Carlos Martín 2015-07-01 15:43:22 +02:00
parent e183a8c242
commit 143017e30d
9 changed files with 130 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/VirtualMachine.h
View File

@ -1566,8 +1566,8 @@ public:
* @param disk_id of the disk * @param disk_id of the disk
* @param snap_id of the snapshot * @param snap_id of the snapshot
*/ */
int get_snapshot_disk(string& ds_id, string& tm_mad, string& disk_id, int get_snapshot_disk(int& ds_id, string& tm_mad, int& disk_id,
string& snap_id); int& snap_id);
/** /**
* Unset the current disk being snapshotted (reverted...) * Unset the current disk being snapshotted (reverted...)
*/ */

4
src/dm/DispatchManagerActions.cc
View File

@ -1901,10 +1901,6 @@ int DispatchManager::disk_snapshot_delete(
default: break; default: break;
} }
vmpool->update(vm);
vm->unlock();
return 0; return 0;
} }

156
src/image/ImageManagerActions.cc
View File

@ -920,11 +920,6 @@ int ImageManager::delete_snapshot(int iid, int sid, string& error)
return -1; return -1;
} }
/* ---------------------------------------------------------------------- */
/* Check action consistency: */
/* state is READY */
/* snapshot can be deleted (not active, no childs, exists) */
/* ---------------------------------------------------------------------- */
Image * img = ipool->get(iid,true); Image * img = ipool->get(iid,true);
if ( img == 0 ) if ( img == 0 )
@ -933,21 +928,6 @@ int ImageManager::delete_snapshot(int iid, int sid, string& error)
return -1; return -1;
} }
if (img->get_state() != Image::READY)
{
error = "Cannot delete snapshot in state " + Image::state_to_str(img->get_state());
img->unlock();
return -1;
}
const Snapshots& snaps = img->get_snapshots();
if (!snaps.test_delete(sid, error))
{
img->unlock();
return -1;
}
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
/* Get DS data for driver */ /* Get DS data for driver */
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
@ -969,17 +949,37 @@ int ImageManager::delete_snapshot(int iid, int sid, string& error)
ds->unlock(); ds->unlock();
/* ---------------------------------------------------------------------- */
/* Check action consistency: */
/* state is READY */
/* snapshot can be deleted (not active, no childs, exists) */
/* ---------------------------------------------------------------------- */
img = ipool->get(iid,true); img = ipool->get(iid,true);
/* ---------------------------------------------------------------------- */
/* Format message and send action to driver */
/* ---------------------------------------------------------------------- */
if ( img == 0 ) if ( img == 0 )
{ {
error = "Image does not exist"; error = "Image does not exist";
return -1; return -1;
} }
if (img->get_state() != Image::READY)
{
error = "Cannot delete snapshot in state " + Image::state_to_str(img->get_state());
img->unlock();
return -1;
}
const Snapshots& snaps = img->get_snapshots();
if (!snaps.test_delete(sid, error))
{
img->unlock();
return -1;
}
/* ---------------------------------------------------------------------- */
/* Format message and send action to driver */
/* ---------------------------------------------------------------------- */
img->set_target_snapshot(sid); img->set_target_snapshot(sid);
string img_tmpl; string img_tmpl;
@ -1013,14 +1013,42 @@ int ImageManager::revert_snapshot(int iid, int sid, string& error)
return -1; return -1;
} }
Image * img = ipool->get(iid,true);
if ( img == 0 )
{
error = "Image does not exist";
return -1;
}
/* ---------------------------------------------------------------------- */
/* Get DS data for driver */
/* ---------------------------------------------------------------------- */
int ds_id = img->get_ds_id();
img->unlock();
string ds_data;
Datastore * ds = dspool->get(ds_id, true);
if ( ds == 0 )
{
error = "Datastore no longer exists";
return -1;
}
ds->to_xml(ds_data);
ds->unlock();
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
/* Check action consistency: */ /* Check action consistency: */
/* state is READY */ /* state is READY */
/* snapshot exists */ /* snapshot exists */
/* snapshot is not the active one */ /* snapshot is not the active one */
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
img = ipool->get(iid,true);
Image * img = ipool->get(iid,true);
if ( img == 0 ) if ( img == 0 )
{ {
@ -1053,38 +1081,9 @@ int ImageManager::revert_snapshot(int iid, int sid, string& error)
return -1; return -1;
} }
/* ---------------------------------------------------------------------- */
/* Get DS data for driver */
/* ---------------------------------------------------------------------- */
int ds_id = img->get_ds_id();
img->unlock();
string ds_data;
Datastore * ds = dspool->get(ds_id, true);
if ( ds == 0 )
{
error = "Datastore no longer exists";
return -1;
}
ds->to_xml(ds_data);
ds->unlock();
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
/* Format message and send action to driver */ /* Format message and send action to driver */
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
img = ipool->get(iid,true);
if ( img == 0 )
{
error = "Image does not exist";
return -1;
}
img->set_target_snapshot(sid); img->set_target_snapshot(sid);
string img_tmpl; string img_tmpl;
@ -1118,12 +1117,6 @@ int ImageManager::flatten_snapshot(int iid, int sid, string& error)
return -1; return -1;
} }
/* ---------------------------------------------------------------------- */
/* Check action consistency: */
/* state is READY */
/* snapshot exists */
/* ---------------------------------------------------------------------- */
Image * img = ipool->get(iid,true); Image * img = ipool->get(iid,true);
if ( img == 0 ) if ( img == 0 )
@ -1132,23 +1125,6 @@ int ImageManager::flatten_snapshot(int iid, int sid, string& error)
return -1; return -1;
} }
if (img->get_state() != Image::READY)
{
error = "Cannot flatten snapshot in state " + Image::state_to_str(img->get_state());
img->unlock();
return -1;
}
const Snapshots& snaps = img->get_snapshots();
if (!snaps.exists(sid))
{
error = "Snapshot does not exist";
img->unlock();
return -1;
}
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
/* Get DS data for driver */ /* Get DS data for driver */
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
@ -1171,8 +1147,11 @@ int ImageManager::flatten_snapshot(int iid, int sid, string& error)
ds->unlock(); ds->unlock();
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
/* Format message and send action to driver */ /* Check action consistency: */
/* state is READY */
/* snapshot exists */
/* ---------------------------------------------------------------------- */ /* ---------------------------------------------------------------------- */
img = ipool->get(iid,true); img = ipool->get(iid,true);
if ( img == 0 ) if ( img == 0 )
@ -1181,6 +1160,27 @@ int ImageManager::flatten_snapshot(int iid, int sid, string& error)
return -1; return -1;
} }
if (img->get_state() != Image::READY)
{
error = "Cannot flatten snapshot in state " + Image::state_to_str(img->get_state());
img->unlock();
return -1;
}
const Snapshots& snaps = img->get_snapshots();
if (!snaps.exists(sid))
{
error = "Snapshot does not exist";
img->unlock();
return -1;
}
/* ---------------------------------------------------------------------- */
/* Format message and send action to driver */
/* ---------------------------------------------------------------------- */
img->set_target_snapshot(sid); img->set_target_snapshot(sid);
string img_tmpl; string img_tmpl;

18
src/lcm/LifeCycleStates.cc
View File

@ -1720,7 +1720,8 @@ void LifeCycleManager::saveas_failure_action(int vid)
void LifeCycleManager::disk_snapshot_success(int vid) void LifeCycleManager::disk_snapshot_success(int vid)
{ {
string disk_id, tm_mad, ds_id, snap_id; string tm_mad;
int disk_id, ds_id, snap_id;
Quotas::QuotaType qt; Quotas::QuotaType qt;
Template *quotas = 0; Template *quotas = 0;
@ -1741,9 +1742,6 @@ void LifeCycleManager::disk_snapshot_success(int vid)
return; return;
} }
int isnap_id = strtol(snap_id.c_str(),NULL,0);
int idisk_id = strtol(disk_id.c_str(),NULL,0);
int uid = vm->get_uid(); int uid = vm->get_uid();
int gid = vm->get_gid(); int gid = vm->get_gid();
@ -1759,7 +1757,7 @@ void LifeCycleManager::disk_snapshot_success(int vid)
case VirtualMachine::DISK_SNAPSHOT_REVERT_POWEROFF: case VirtualMachine::DISK_SNAPSHOT_REVERT_POWEROFF:
case VirtualMachine::DISK_SNAPSHOT_REVERT_SUSPENDED: case VirtualMachine::DISK_SNAPSHOT_REVERT_SUSPENDED:
vm->log("LCM", Log::INFO, "VM disk snapshot operation completed."); vm->log("LCM", Log::INFO, "VM disk snapshot operation completed.");
vm->revert_disk_snapshot(idisk_id, isnap_id); vm->revert_disk_snapshot(disk_id, snap_id);
break; break;
case VirtualMachine::DISK_SNAPSHOT_DELETE: case VirtualMachine::DISK_SNAPSHOT_DELETE:
@ -1767,7 +1765,7 @@ void LifeCycleManager::disk_snapshot_success(int vid)
case VirtualMachine::DISK_SNAPSHOT_DELETE_POWEROFF: case VirtualMachine::DISK_SNAPSHOT_DELETE_POWEROFF:
case VirtualMachine::DISK_SNAPSHOT_DELETE_SUSPENDED: case VirtualMachine::DISK_SNAPSHOT_DELETE_SUSPENDED:
vm->log("LCM", Log::INFO, "VM disk snapshot deleted."); vm->log("LCM", Log::INFO, "VM disk snapshot deleted.");
vm->delete_disk_snapshot(idisk_id, isnap_id, qt, &quotas); vm->delete_disk_snapshot(disk_id, snap_id, qt, &quotas);
break; break;
default: default:
@ -1815,7 +1813,8 @@ void LifeCycleManager::disk_snapshot_success(int vid)
void LifeCycleManager::disk_snapshot_failure(int vid) void LifeCycleManager::disk_snapshot_failure(int vid)
{ {
string disk_id, tm_mad, ds_id, snap_id; string tm_mad;
int disk_id, ds_id, snap_id;
Quotas::QuotaType qt; Quotas::QuotaType qt;
Template *quotas = 0; Template *quotas = 0;
@ -1836,9 +1835,6 @@ void LifeCycleManager::disk_snapshot_failure(int vid)
return; return;
} }
int isnap_id = strtol(snap_id.c_str(),NULL,0);
int idisk_id = strtol(disk_id.c_str(),NULL,0);
int uid = vm->get_uid(); int uid = vm->get_uid();
int gid = vm->get_gid(); int gid = vm->get_gid();
@ -1851,7 +1847,7 @@ void LifeCycleManager::disk_snapshot_failure(int vid)
case VirtualMachine::DISK_SNAPSHOT_POWEROFF: case VirtualMachine::DISK_SNAPSHOT_POWEROFF:
case VirtualMachine::DISK_SNAPSHOT_SUSPENDED: case VirtualMachine::DISK_SNAPSHOT_SUSPENDED:
vm->log("LCM", Log::ERROR, "Could not take disk snapshot."); vm->log("LCM", Log::ERROR, "Could not take disk snapshot.");
vm->delete_disk_snapshot(idisk_id, isnap_id, qt, &quotas); vm->delete_disk_snapshot(disk_id, snap_id, qt, &quotas);
break; break;
case VirtualMachine::DISK_SNAPSHOT_REVERT: case VirtualMachine::DISK_SNAPSHOT_REVERT:

10
src/rm/RequestManagerVirtualMachine.cc
View File

@ -2377,7 +2377,7 @@ void VirtualMachineDiskSnapshotCreate::request_execute(
if (disk == 0) if (disk == 0)
{ {
failure_response(ACTION, request_error("VM disk does not exists", ""), att); failure_response(ACTION, request_error("VM disk does not exist", ""), att);
vm->unlock(); vm->unlock();
@ -2387,6 +2387,7 @@ void VirtualMachineDiskSnapshotCreate::request_execute(
string disk_size = disk->vector_value("SIZE"); string disk_size = disk->vector_value("SIZE");
string ds_id = disk->vector_value("DATASTORE_ID"); string ds_id = disk->vector_value("DATASTORE_ID");
bool persistent = VirtualMachine::is_persistent(disk); bool persistent = VirtualMachine::is_persistent(disk);
bool is_volatile = VirtualMachine::is_volatile(disk);
vm->get_permissions(vm_perms); vm->get_permissions(vm_perms);
@ -2394,7 +2395,7 @@ void VirtualMachineDiskSnapshotCreate::request_execute(
RequestAttributes att_quota(vm_perms.uid, vm_perms.gid, att); RequestAttributes att_quota(vm_perms.uid, vm_perms.gid, att);
if (VirtualMachine::is_volatile(disk)) if (is_volatile)
{ {
failure_response(ACTION, request_error("Cannot make snapshots on " failure_response(ACTION, request_error("Cannot make snapshots on "
"volatile disks",""), att); "volatile disks",""), att);
@ -2484,7 +2485,7 @@ void VirtualMachineDiskSnapshotRevert::request_execute(
} }
else else
{ {
success_response(snap_id, att); success_response(id, att);
} }
return; return;
@ -2493,7 +2494,6 @@ void VirtualMachineDiskSnapshotRevert::request_execute(
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
void VirtualMachineDiskSnapshotDelete::request_execute( void VirtualMachineDiskSnapshotDelete::request_execute(
xmlrpc_c::paramList const& paramList, xmlrpc_c::paramList const& paramList,
RequestAttributes& att) RequestAttributes& att)
@ -2523,7 +2523,7 @@ void VirtualMachineDiskSnapshotDelete::request_execute(
} }
else else
{ {
success_response(snap_id, att); success_response(id, att);
} }
return; return;

33
src/tm/TransferManager.cc
View File

@ -2075,20 +2075,17 @@ void TransferManager::saveas_hot_action(int vid)
if (vm == 0) if (vm == 0)
{ {
vm->log("TM", Log::ERROR, "Could not obtain the VM"); return;
goto error_common;
} }
if (!vm->hasHistory()) if (!vm->hasHistory())
{ {
vm->log("TM", Log::ERROR, "The VM has no history"); goto error_history;
goto error_common;
} }
if (vm->get_saveas_disk(disk_id, src, image_id, snap_id, tm_mad, ds_id)!= 0) if (vm->get_saveas_disk(disk_id, src, image_id, snap_id, tm_mad, ds_id)!= 0)
{ {
vm->log("TM", Log::ERROR,"Could not get disk information to export it"); goto error_disk;
goto error_common;
} }
tm_md = get(); tm_md = get();
@ -2125,6 +2122,14 @@ void TransferManager::saveas_hot_action(int vid)
return; return;
error_history:
os << "saveas_hot_transfer, the VM has no history";
goto error_common;
error_disk:
os << "saveas_hot_transfer, could not get disk information to export it";
goto error_common;
error_driver: error_driver:
os << "saveas_hot_transfer, error getting TM driver."; os << "saveas_hot_transfer, error getting TM driver.";
goto error_common; goto error_common;
@ -2169,9 +2174,9 @@ int TransferManager::snapshot_transfer_command(
VirtualMachine * vm, const char * snap_action, ostream& xfr) VirtualMachine * vm, const char * snap_action, ostream& xfr)
{ {
string tm_mad; string tm_mad;
string ds_id; int ds_id;
string disk_id; int disk_id;
string snap_id; int snap_id;
if (vm->get_snapshot_disk(ds_id, tm_mad, disk_id, snap_id) == -1) if (vm->get_snapshot_disk(ds_id, tm_mad, disk_id, snap_id) == -1)
{ {
@ -2221,14 +2226,12 @@ void TransferManager::do_snapshot_action(int vid, const char * snap_action)
if (vm == 0) if (vm == 0)
{ {
vm->log("TM", Log::ERROR, "Could not obtain the VM"); return;
goto error_common;
} }
if (!vm->hasHistory()) if (!vm->hasHistory())
{ {
vm->log("TM", Log::ERROR, "The VM has no history"); goto error_history;
goto error_common;
} }
xfr_name = vm->get_transfer_file() + ".disk_snapshot"; xfr_name = vm->get_transfer_file() + ".disk_snapshot";
@ -2258,6 +2261,10 @@ error_driver:
os << "disk_snapshot, error getting TM driver."; os << "disk_snapshot, error getting TM driver.";
goto error_common; goto error_common;
error_history:
os << "disk_snapshot, the VM has no history";
goto error_common;
error_file: error_file:
os << "disk_snapshot, could not open file: " << xfr_name; os << "disk_snapshot, could not open file: " << xfr_name;
goto error_common; goto error_common;

2
src/vm/Snapshots.cc
View File

@ -311,7 +311,7 @@ bool Snapshots::test_delete(unsigned int id, string& error) const
if (snapshot == 0) if (snapshot == 0)
{ {
error = "Snapshot does not exists"; error = "Snapshot does not exist";
return false; return false;
} }

20
src/vm/VirtualMachine.cc
View File

@ -4153,8 +4153,8 @@ void VirtualMachine::clear_snapshot_disk()
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
int VirtualMachine::get_snapshot_disk(string& ds_id, string& tm_mad, int VirtualMachine::get_snapshot_disk(int& ds_id, string& tm_mad,
string& disk_id, string& snap_id) int& disk_id, int& snap_id)
{ {
vector<Attribute *> disks; vector<Attribute *> disks;
VectorAttribute * disk; VectorAttribute * disk;
@ -4175,7 +4175,7 @@ int VirtualMachine::get_snapshot_disk(string& ds_id, string& tm_mad,
if ( disk->vector_value("DISK_SNAPSHOT_ACTIVE") == "YES" ) if ( disk->vector_value("DISK_SNAPSHOT_ACTIVE") == "YES" )
{ {
map<int, Snapshots *>::iterator it; map<int, Snapshots *>::iterator it;
int did; int did, rc;
if (disk->vector_value("DISK_ID", did) == -1) if (disk->vector_value("DISK_ID", did) == -1)
{ {
@ -4190,11 +4190,11 @@ int VirtualMachine::get_snapshot_disk(string& ds_id, string& tm_mad,
} }
tm_mad = disk->vector_value("TM_MAD"); tm_mad = disk->vector_value("TM_MAD");
ds_id = disk->vector_value("DATASTORE_ID"); rc = disk->vector_value("DATASTORE_ID", ds_id);
disk_id = disk->vector_value("DISK_ID"); rc += disk->vector_value("DISK_ID", disk_id);
snap_id = disk->vector_value("DISK_SNAPSHOT_ID"); rc += disk->vector_value("DISK_SNAPSHOT_ID", snap_id);
if (snap_id.empty()||tm_mad.empty()||ds_id.empty()||disk_id.empty()) if (tm_mad.empty() || rc != 0)
{ {
return -1; return -1;
} }
@ -4221,7 +4221,7 @@ int VirtualMachine::new_disk_snapshot(int did, const string& tag, string& error)
if ( disk == 0 ) if ( disk == 0 )
{ {
error = "VM disk does not exists"; error = "VM disk does not exist";
return -1; return -1;
} }
@ -4280,7 +4280,7 @@ const Snapshots * VirtualMachine::get_disk_snapshots(int did, string& error) con
if ( disk == 0 ) if ( disk == 0 )
{ {
error = "VM disk does not exists"; error = "VM disk does not exist";
return 0; return 0;
} }
@ -4288,7 +4288,7 @@ const Snapshots * VirtualMachine::get_disk_snapshots(int did, string& error) con
if (it == snapshots.end()) if (it == snapshots.end())
{ {
error = "Snapshot does not exists"; error = "Snapshot does not exist";
return 0; return 0;
} }

6
src/vmm/VirtualMachineManager.cc
View File

@ -2121,7 +2121,8 @@ void VirtualMachineManager::disk_snapshot_create_action(int vid)
string snap_cmd, snap_cmd_rollback; string snap_cmd, snap_cmd_rollback;
string disk_path; string disk_path;
string ds_id, tm_mad, disk_id, snap_id; string tm_mad;
int ds_id, disk_id, snap_id;
int rc; int rc;
@ -2240,7 +2241,8 @@ void VirtualMachineManager::disk_snapshot_revert_action(int vid)
string snap_cmd; string snap_cmd;
string disk_path; string disk_path;
string ds_id, tm_mad, disk_id, snap_id; string tm_mad;
int ds_id, disk_id, snap_id;
int rc; int rc;