mirror of
https://github.com/OpenNebula/one.git
synced 2026-11-20 11:52:37 +09:00
1230 lines
29 KiB
C++
1230 lines
29 KiB
C++
/* -------------------------------------------------------------------------- */
|
|
/* Copyright 2002-2015, 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 "ImageManager.h"
|
|
#include "NebulaLog.h"
|
|
#include "ImagePool.h"
|
|
#include "SyncRequest.h"
|
|
#include "Template.h"
|
|
#include "Nebula.h"
|
|
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
Image * ImageManager::acquire_image(int vm_id, int image_id, string& error)
|
|
{
|
|
Image * img;
|
|
int rc;
|
|
|
|
img = ipool->get(image_id,true);
|
|
|
|
if ( img == 0 )
|
|
{
|
|
ostringstream oss;
|
|
oss << "Image with ID: " << image_id << " does not exist";
|
|
|
|
error = oss.str();
|
|
return 0;
|
|
}
|
|
|
|
rc = acquire_image(vm_id, img, error);
|
|
|
|
if ( rc != 0 )
|
|
{
|
|
img->unlock();
|
|
img = 0;
|
|
}
|
|
|
|
return img;
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
Image * ImageManager::acquire_image(int vm_id, const string& name, int uid, string& error)
|
|
{
|
|
Image * img;
|
|
int rc;
|
|
|
|
img = ipool->get(name,uid,true);
|
|
|
|
if ( img == 0 )
|
|
{
|
|
ostringstream oss;
|
|
oss << "User " << uid << " does not own an image with name: " << name
|
|
<< " . Set IMAGE_UNAME or IMAGE_UID of owner in DISK.";
|
|
|
|
error = oss.str();
|
|
return 0;
|
|
}
|
|
|
|
rc = acquire_image(vm_id, img, error);
|
|
|
|
if ( rc != 0 )
|
|
{
|
|
img->unlock();
|
|
img = 0;
|
|
}
|
|
|
|
return img;
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
int ImageManager::acquire_image(int vm_id, Image *img, string& error)
|
|
{
|
|
int rc = 0;
|
|
|
|
ostringstream oss;
|
|
|
|
switch(img->get_type())
|
|
{
|
|
case Image::OS:
|
|
case Image::DATABLOCK:
|
|
case Image::CDROM:
|
|
break;
|
|
|
|
case Image::KERNEL:
|
|
case Image::RAMDISK:
|
|
case Image::CONTEXT:
|
|
oss << "Image " << img->get_oid() << " (" << img->get_name() << ") "
|
|
<< "of type " << Image::type_to_str(img->get_type())
|
|
<< " cannot be used as DISK.";
|
|
|
|
error = oss.str();
|
|
return -1;
|
|
}
|
|
|
|
switch (img->get_state())
|
|
{
|
|
case Image::READY:
|
|
img->inc_running(vm_id);
|
|
|
|
if ( img->is_persistent() )
|
|
{
|
|
img->set_state(Image::USED_PERS);
|
|
}
|
|
else
|
|
{
|
|
img->set_state(Image::USED);
|
|
}
|
|
|
|
ipool->update(img);
|
|
break;
|
|
|
|
case Image::USED_PERS:
|
|
oss << "Cannot acquire image " << img->get_oid()
|
|
<< ", it is persistent and already in use";
|
|
|
|
error = oss.str();
|
|
rc = -1;
|
|
break;
|
|
|
|
case Image::USED:
|
|
img->inc_running(vm_id);
|
|
ipool->update(img);
|
|
break;
|
|
|
|
case Image::INIT:
|
|
case Image::DISABLED:
|
|
case Image::LOCKED:
|
|
case Image::ERROR:
|
|
case Image::DELETE:
|
|
case Image::CLONE:
|
|
oss << "Cannot acquire image " << img->get_oid()
|
|
<<", it is in state: " << Image::state_to_str(img->get_state());
|
|
|
|
error = oss.str();
|
|
rc = -1;
|
|
break;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
void ImageManager::release_image(int vm_id, int iid, bool failed)
|
|
{
|
|
ostringstream oss;
|
|
|
|
Image * img = ipool->get(iid,true);
|
|
|
|
if ( img == 0 )
|
|
{
|
|
return;
|
|
}
|
|
|
|
switch(img->get_type())
|
|
{
|
|
case Image::OS:
|
|
case Image::DATABLOCK:
|
|
case Image::CDROM:
|
|
break;
|
|
|
|
case Image::KERNEL:
|
|
case Image::RAMDISK:
|
|
case Image::CONTEXT:
|
|
NebulaLog::log("ImM", Log::ERROR, "Trying to release a KERNEL, "
|
|
"RAMDISK or CONTEXT image");
|
|
img->unlock();
|
|
return;
|
|
}
|
|
|
|
switch (img->get_state())
|
|
{
|
|
case Image::USED_PERS:
|
|
img->dec_running(vm_id);
|
|
|
|
if (failed == true)
|
|
{
|
|
img->set_state(Image::ERROR);
|
|
}
|
|
else
|
|
{
|
|
img->set_state(Image::READY);
|
|
}
|
|
|
|
ipool->update(img);
|
|
|
|
img->unlock();
|
|
break;
|
|
|
|
case Image::USED:
|
|
if ( img->dec_running(vm_id) == 0 && img->get_cloning() == 0 )
|
|
{
|
|
img->set_state(Image::READY);
|
|
}
|
|
|
|
ipool->update(img);
|
|
|
|
img->unlock();
|
|
break;
|
|
|
|
case Image::LOCKED:
|
|
oss << "Releasing image in wrong state: "
|
|
<< Image::state_to_str(img->get_state());
|
|
|
|
NebulaLog::log("ImM", Log::ERROR, oss.str());
|
|
|
|
img->unlock();
|
|
break;
|
|
|
|
case Image::CLONE:
|
|
case Image::DELETE:
|
|
case Image::INIT:
|
|
case Image::DISABLED:
|
|
case Image::READY:
|
|
case Image::ERROR:
|
|
oss << "Releasing image in wrong state: "
|
|
<< Image::state_to_str(img->get_state());
|
|
|
|
NebulaLog::log("ImM", Log::ERROR, oss.str());
|
|
|
|
img->unlock();
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
void ImageManager::release_cloning_image(int iid, int clone_img_id)
|
|
{
|
|
Image * img = ipool->get(iid,true);
|
|
|
|
if ( img == 0 )
|
|
{
|
|
return;
|
|
}
|
|
|
|
switch(img->get_type())
|
|
{
|
|
case Image::OS:
|
|
case Image::DATABLOCK:
|
|
case Image::CDROM:
|
|
break;
|
|
|
|
case Image::KERNEL:
|
|
case Image::RAMDISK:
|
|
case Image::CONTEXT:
|
|
NebulaLog::log("ImM", Log::ERROR, "Trying to release a cloning "
|
|
"KERNEL, RAMDISK or CONTEXT image");
|
|
img->unlock();
|
|
return;
|
|
}
|
|
|
|
switch (img->get_state())
|
|
{
|
|
case Image::USED:
|
|
case Image::CLONE:
|
|
if (img->dec_cloning(clone_img_id) == 0 && img->get_running() == 0)
|
|
{
|
|
img->set_state(Image::READY);
|
|
}
|
|
|
|
ipool->update(img);
|
|
break;
|
|
|
|
case Image::DELETE:
|
|
case Image::INIT:
|
|
case Image::DISABLED:
|
|
case Image::READY:
|
|
case Image::ERROR:
|
|
case Image::USED_PERS:
|
|
case Image::LOCKED:
|
|
ostringstream oss;
|
|
|
|
oss << "Releasing image in wrong state: "
|
|
<< Image::state_to_str(img->get_state());
|
|
|
|
NebulaLog::log("ImM", Log::ERROR, oss.str());
|
|
break;
|
|
}
|
|
|
|
img->unlock();
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
int ImageManager::enable_image(int iid, bool to_enable, string& error_str)
|
|
{
|
|
int rc = 0;
|
|
Image * img;
|
|
|
|
ostringstream oss;
|
|
|
|
img = ipool->get(iid,true);
|
|
|
|
if ( img == 0 )
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
if ( to_enable == true )
|
|
{
|
|
switch (img->get_state())
|
|
{
|
|
case Image::DISABLED:
|
|
case Image::ERROR:
|
|
img->set_state(Image::READY);
|
|
ipool->update(img);
|
|
case Image::READY:
|
|
break;
|
|
default:
|
|
oss << "Image cannot be in state "
|
|
<< Image::state_to_str(img->get_state()) << ".";
|
|
error_str = oss.str();
|
|
|
|
rc = -1;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch (img->get_state())
|
|
{
|
|
case Image::READY:
|
|
case Image::ERROR:
|
|
img->set_state(Image::DISABLED);
|
|
ipool->update(img);
|
|
case Image::DISABLED:
|
|
break;
|
|
default:
|
|
oss << "Image cannot be in state "
|
|
<< Image::state_to_str(img->get_state()) << ".";
|
|
error_str = oss.str();
|
|
|
|
rc = -1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
img->unlock();
|
|
|
|
return rc;
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
int ImageManager::delete_image(int iid, string& error_str)
|
|
{
|
|
Image * img;
|
|
Datastore * ds;
|
|
|
|
string source;
|
|
string img_tmpl;
|
|
string * drv_msg;
|
|
string ds_data;
|
|
|
|
long long size;
|
|
int ds_id;
|
|
|
|
int uid;
|
|
int gid;
|
|
int cloning_id = -1;
|
|
int vm_saving_id = -1;
|
|
|
|
ostringstream oss;
|
|
|
|
img = ipool->get(iid,true);
|
|
|
|
if ( img == 0 )
|
|
{
|
|
error_str = "Image does not exist";
|
|
return -1;
|
|
}
|
|
|
|
ds_id = img->get_ds_id();
|
|
|
|
img->unlock();
|
|
|
|
ds = dspool->get(ds_id, true);
|
|
|
|
if ( ds == 0 )
|
|
{
|
|
error_str = "Datastore no longer exists cannot remove image";
|
|
return -1;
|
|
}
|
|
|
|
ds->to_xml(ds_data);
|
|
|
|
ds->unlock();
|
|
|
|
img = ipool->get(iid,true);
|
|
|
|
if ( img == 0 )
|
|
{
|
|
error_str = "Image does not exist";
|
|
return -1;
|
|
}
|
|
|
|
switch(img->get_state())
|
|
{
|
|
case Image::READY:
|
|
if ( img->get_running() != 0 )
|
|
{
|
|
oss << "There are " << img->get_running() << " VMs using it.";
|
|
error_str = oss.str();
|
|
|
|
img->unlock();
|
|
return -1; //Cannot remove images in use
|
|
}
|
|
break;
|
|
|
|
case Image::CLONE:
|
|
oss << "There are " << img->get_cloning() << " active clone operations.";
|
|
error_str = oss.str();
|
|
|
|
img->unlock();
|
|
return -1; //Cannot remove images in use
|
|
break;
|
|
|
|
case Image::USED:
|
|
case Image::USED_PERS:
|
|
oss << "There are " << img->get_running() << " VMs using it.";
|
|
error_str = oss.str();
|
|
|
|
img->unlock();
|
|
return -1; //Cannot remove images in use
|
|
break;
|
|
|
|
case Image::INIT:
|
|
case Image::DISABLED:
|
|
case Image::ERROR:
|
|
case Image::DELETE:
|
|
break;
|
|
|
|
case Image::LOCKED:
|
|
cloning_id = img->get_cloning_id();
|
|
|
|
if ( img->is_saving() )
|
|
{
|
|
img->get_template_attribute("SAVED_VM_ID", vm_saving_id);
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
/* ------------------- Send RM operation request to the DS -------------- */
|
|
|
|
const ImageManagerDriver* imd = get();
|
|
|
|
if ( imd == 0 )
|
|
{
|
|
error_str = "Error getting ImageManagerDriver";
|
|
|
|
img->unlock();
|
|
return -1;
|
|
}
|
|
|
|
drv_msg = format_message(img->to_xml(img_tmpl), ds_data);
|
|
source = img->get_source();
|
|
size = img->get_size();
|
|
ds_id = img->get_ds_id();
|
|
uid = img->get_uid();
|
|
gid = img->get_gid();
|
|
|
|
if (source.empty())
|
|
{
|
|
string err_str;
|
|
int rc;
|
|
|
|
rc = ipool->drop(img, err_str);
|
|
|
|
if ( rc < 0 )
|
|
{
|
|
NebulaLog::log("ImM",Log::ERROR,
|
|
"Image could not be removed from DB");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
imd->rm(img->get_oid(), *drv_msg);
|
|
img->set_state(Image::DELETE);
|
|
|
|
img->clear_cloning_id();
|
|
|
|
ipool->update(img);
|
|
}
|
|
|
|
long long snap_size = (img->get_snapshots()).get_total_size();
|
|
|
|
img->unlock();
|
|
|
|
delete drv_msg;
|
|
|
|
/* -------------------- Update Group & User quota counters -------------- */
|
|
|
|
Template img_usage;
|
|
|
|
img_usage.add("DATASTORE", ds_id);
|
|
img_usage.add("SIZE", size + snap_size);
|
|
|
|
Quotas::ds_del(uid, gid, &img_usage);
|
|
|
|
/* --------------- Update cloning image if needed ----------------------- */
|
|
|
|
if ( cloning_id != -1 )
|
|
{
|
|
release_cloning_image(cloning_id, iid);
|
|
}
|
|
|
|
ds = dspool->get(ds_id, true);
|
|
|
|
if ( ds != 0 )
|
|
{
|
|
ds->del_image(iid);
|
|
dspool->update(ds);
|
|
|
|
ds->unlock();
|
|
}
|
|
|
|
/* --------------- Release VM in hotplug -------------------------------- */
|
|
|
|
// This is only needed if the image is deleted before the mkfs action
|
|
// is completed
|
|
|
|
if ( vm_saving_id != -1 )
|
|
{
|
|
VirtualMachine* vm;
|
|
VirtualMachinePool* vmpool = Nebula::instance().get_vmpool();
|
|
|
|
if ((vm = vmpool->get(vm_saving_id, true)) != 0)
|
|
{
|
|
vm->clear_saveas_state();
|
|
|
|
vm->clear_saveas_disk();
|
|
|
|
vmpool->update(vm);
|
|
|
|
vm->unlock();
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
int ImageManager::can_clone_image( int cloning_id,
|
|
ostringstream& oss_error)
|
|
{
|
|
Image * img;
|
|
|
|
img = ipool->get(cloning_id, true);
|
|
|
|
if (img == 0)
|
|
{
|
|
oss_error << "Cannot clone image, it does not exist";
|
|
return -1;
|
|
}
|
|
|
|
Image::ImageState state = img->get_state();
|
|
|
|
img->unlock();
|
|
|
|
switch(state)
|
|
{
|
|
case Image::USED_PERS:
|
|
case Image::INIT:
|
|
case Image::DISABLED:
|
|
case Image::ERROR:
|
|
case Image::DELETE:
|
|
case Image::LOCKED:
|
|
oss_error << "Cannot clone image in state: "
|
|
<< Image::state_to_str(state);
|
|
|
|
return -1;
|
|
break;
|
|
|
|
case Image::CLONE:
|
|
case Image::READY:
|
|
case Image::USED:
|
|
default:
|
|
return 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
int ImageManager::clone_image(int new_id,
|
|
int cloning_id,
|
|
const string& ds_data,
|
|
string& error)
|
|
{
|
|
const ImageManagerDriver* imd = get();
|
|
|
|
ostringstream oss;
|
|
Image * img;
|
|
|
|
string path;
|
|
string img_tmpl;
|
|
string* drv_msg;
|
|
|
|
if ( imd == 0 )
|
|
{
|
|
error = "Could not get datastore driver";
|
|
|
|
NebulaLog::log("ImM", Log::ERROR, error);
|
|
return -1;
|
|
}
|
|
|
|
img = ipool->get(cloning_id, true);
|
|
|
|
if (img == 0)
|
|
{
|
|
error = "Cannot clone image, it does not exist";
|
|
return -1;
|
|
}
|
|
|
|
switch(img->get_state())
|
|
{
|
|
case Image::READY:
|
|
img->inc_cloning(new_id);
|
|
|
|
if (img->is_persistent())
|
|
{
|
|
img->set_state(Image::CLONE);
|
|
}
|
|
else
|
|
{
|
|
img->set_state(Image::USED);
|
|
}
|
|
|
|
ipool->update(img);
|
|
|
|
img->unlock();
|
|
break;
|
|
|
|
case Image::USED:
|
|
case Image::CLONE:
|
|
img->inc_cloning(new_id);
|
|
|
|
ipool->update(img);
|
|
|
|
img->unlock();
|
|
break;
|
|
|
|
case Image::USED_PERS:
|
|
case Image::INIT:
|
|
case Image::DISABLED:
|
|
case Image::ERROR:
|
|
case Image::DELETE:
|
|
case Image::LOCKED:
|
|
oss << "Cannot clone image in state: "
|
|
<< Image::state_to_str(img->get_state());
|
|
|
|
error = oss.str();
|
|
img->unlock();
|
|
return -1;
|
|
break;
|
|
}
|
|
|
|
img = ipool->get(new_id,true);
|
|
|
|
if (img == 0) //TODO: Rollback cloning counter
|
|
{
|
|
error = "Target image deleted during cloning operation";
|
|
return -1;
|
|
}
|
|
|
|
drv_msg = format_message(img->to_xml(img_tmpl), ds_data);
|
|
|
|
imd->clone(img->get_oid(), *drv_msg);
|
|
|
|
oss << "Cloning image " << img->get_path()
|
|
<<" to repository as image "<<img->get_oid();
|
|
|
|
NebulaLog::log("ImM", Log::INFO, oss);
|
|
|
|
img->unlock();
|
|
|
|
delete drv_msg;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
int ImageManager::register_image(int iid, const string& ds_data, string& error)
|
|
{
|
|
const ImageManagerDriver* imd = get();
|
|
|
|
ostringstream oss;
|
|
Image * img;
|
|
|
|
string path;
|
|
string img_tmpl;
|
|
string * drv_msg;
|
|
|
|
|
|
if ( imd == 0 )
|
|
{
|
|
error = "Could not get datastore driver";
|
|
NebulaLog::log("ImM",Log::ERROR, error);
|
|
return -1;
|
|
}
|
|
|
|
img = ipool->get(iid,true);
|
|
|
|
if (img == 0)
|
|
{
|
|
error = "Image deleted during copy operation";
|
|
return -1;
|
|
}
|
|
|
|
drv_msg = format_message(img->to_xml(img_tmpl), ds_data);
|
|
path = img->get_path();
|
|
|
|
if ( path.empty() == true ) //NO PATH
|
|
{
|
|
string source = img->get_source();
|
|
|
|
if ( img->is_saving() || img->get_type() == Image::DATABLOCK )
|
|
{
|
|
imd->mkfs(img->get_oid(), *drv_msg);
|
|
|
|
oss << "Creating disk at " << source << " of "<< img->get_size()
|
|
<< "Mb (type: " << img->get_fstype() << ")";
|
|
}
|
|
else if ( !source.empty() ) //Source in Template
|
|
{
|
|
img->set_state(Image::READY);
|
|
ipool->update(img);
|
|
|
|
oss << "Using source " << source
|
|
<< " from template for image " << img->get_name();
|
|
}
|
|
}
|
|
else //PATH -> COPY TO REPOSITORY AS SOURCE
|
|
{
|
|
imd->cp(img->get_oid(), *drv_msg);
|
|
oss << "Copying " << path <<" to repository for image "<<img->get_oid();
|
|
}
|
|
|
|
NebulaLog::log("ImM",Log::INFO,oss);
|
|
|
|
img->unlock();
|
|
|
|
delete drv_msg;
|
|
|
|
return 0;
|
|
}
|
|
/* -------------------------------------------------------------------------- */
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
int ImageManager::stat_image(Template* img_tmpl,
|
|
const string& ds_data,
|
|
string& res)
|
|
{
|
|
const ImageManagerDriver* imd = get();
|
|
|
|
string* drv_msg;
|
|
string type_att;
|
|
|
|
ostringstream img_data;
|
|
|
|
SyncRequest sr;
|
|
|
|
int rc = 0;
|
|
|
|
if ( imd == 0 )
|
|
{
|
|
res = "Could not get datastore driver";
|
|
NebulaLog::log("ImM",Log::ERROR, res);
|
|
return -1;
|
|
}
|
|
|
|
img_tmpl->get("TYPE", type_att);
|
|
|
|
switch (Image::str_to_type(type_att))
|
|
{
|
|
case Image::OS:
|
|
case Image::CDROM:
|
|
case Image::KERNEL:
|
|
case Image::RAMDISK:
|
|
case Image::CONTEXT:
|
|
img_tmpl->get("SOURCE", res);
|
|
|
|
if (!res.empty())
|
|
{
|
|
long long size_l;
|
|
|
|
if (!img_tmpl->get("SIZE", size_l))
|
|
{
|
|
res = "Wrong number or missing SIZE attribute.";
|
|
return -1;
|
|
}
|
|
|
|
img_tmpl->get("SIZE", res);
|
|
|
|
return 0;
|
|
}
|
|
|
|
img_tmpl->get("PATH", res);
|
|
|
|
if (res.empty())
|
|
{
|
|
res = "Either PATH or SOURCE are required for " + type_att;
|
|
return -1;
|
|
}
|
|
|
|
img_data << "<IMAGE><PATH>" << res << "</PATH></IMAGE>";
|
|
break;
|
|
|
|
case Image::DATABLOCK:
|
|
img_tmpl->get("PATH", res);
|
|
|
|
if (res.empty())//no PATH
|
|
{
|
|
long long size_l;
|
|
|
|
if (!img_tmpl->get("SIZE", size_l))
|
|
{
|
|
res = "Wrong number or missing SIZE attribute.";
|
|
return -1;
|
|
}
|
|
|
|
img_tmpl->get("SIZE", res);
|
|
|
|
return 0;
|
|
}
|
|
else
|
|
{
|
|
img_data << "<IMAGE><PATH>" << res << "</PATH></IMAGE>";
|
|
}
|
|
break;
|
|
}
|
|
|
|
add_request(&sr);
|
|
|
|
drv_msg = format_message(img_data.str(), ds_data);
|
|
|
|
imd->stat(sr.id, *drv_msg);
|
|
|
|
sr.wait();
|
|
|
|
delete drv_msg;
|
|
|
|
res = sr.message;
|
|
|
|
if ( sr.result != true )
|
|
{
|
|
rc = -1;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
string * ImageManager::format_message(
|
|
const string& img_data,
|
|
const string& ds_data)
|
|
{
|
|
ostringstream oss;
|
|
|
|
oss << "<DS_DRIVER_ACTION_DATA>"
|
|
<< img_data
|
|
<< ds_data
|
|
<< "</DS_DRIVER_ACTION_DATA>";
|
|
|
|
return one_util::base64_encode(oss.str());
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
void ImageManager::set_image_snapshots(int iid, const Snapshots& s)
|
|
{
|
|
Image * img = ipool->get(iid,true);
|
|
|
|
if ( img == 0 )
|
|
{
|
|
return;
|
|
}
|
|
|
|
switch(img->get_type())
|
|
{
|
|
case Image::OS:
|
|
case Image::DATABLOCK:
|
|
break;
|
|
|
|
case Image::KERNEL:
|
|
case Image::RAMDISK:
|
|
case Image::CONTEXT:
|
|
case Image::CDROM:
|
|
img->unlock();
|
|
return;
|
|
}
|
|
|
|
if (img->get_state() != Image::USED_PERS)
|
|
{
|
|
img->unlock();
|
|
return;
|
|
}
|
|
|
|
img->set_snapshots(s);
|
|
|
|
ipool->update(img);
|
|
|
|
img->unlock();
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
int ImageManager::delete_snapshot(int iid, int sid, string& error)
|
|
{
|
|
const ImageManagerDriver* imd = get();
|
|
|
|
if ( imd == 0 )
|
|
{
|
|
error = "Could not get datastore driver";
|
|
NebulaLog::log("ImM",Log::ERROR, error);
|
|
|
|
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: */
|
|
/* state is READY */
|
|
/* snapshot can be deleted (not active, no childs, exists) */
|
|
/* ---------------------------------------------------------------------- */
|
|
img = ipool->get(iid,true);
|
|
|
|
if ( img == 0 )
|
|
{
|
|
error = "Image does not exist";
|
|
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);
|
|
|
|
string img_tmpl;
|
|
string * drv_msg = format_message(img->to_xml(img_tmpl), ds_data);
|
|
|
|
imd->snapshot_delete(iid, *drv_msg);
|
|
|
|
img->set_state(Image::LOCKED);
|
|
|
|
ipool->update(img);
|
|
|
|
img->unlock();
|
|
|
|
delete drv_msg;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
int ImageManager::revert_snapshot(int iid, int sid, string& error)
|
|
{
|
|
const ImageManagerDriver* imd = get();
|
|
|
|
if ( imd == 0 )
|
|
{
|
|
error = "Could not get datastore driver";
|
|
NebulaLog::log("ImM",Log::ERROR, error);
|
|
|
|
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: */
|
|
/* state is READY */
|
|
/* snapshot exists */
|
|
/* snapshot is not the active one */
|
|
/* ---------------------------------------------------------------------- */
|
|
img = ipool->get(iid,true);
|
|
|
|
if ( img == 0 )
|
|
{
|
|
error = "Image does not exist";
|
|
return -1;
|
|
}
|
|
|
|
if (img->get_state() != Image::READY)
|
|
{
|
|
error = "Cannot revert to 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;
|
|
}
|
|
|
|
if (snaps.get_active_id() == sid)
|
|
{
|
|
error = "Snapshot is already the active one";
|
|
|
|
img->unlock();
|
|
return -1;
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
/* Format message and send action to driver */
|
|
/* ---------------------------------------------------------------------- */
|
|
img->set_target_snapshot(sid);
|
|
|
|
string img_tmpl;
|
|
string * drv_msg = format_message(img->to_xml(img_tmpl), ds_data);
|
|
|
|
imd->snapshot_revert(iid, *drv_msg);
|
|
|
|
img->set_state(Image::LOCKED);
|
|
|
|
ipool->update(img);
|
|
|
|
img->unlock();
|
|
|
|
delete drv_msg;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
int ImageManager::flatten_snapshot(int iid, int sid, string& error)
|
|
{
|
|
const ImageManagerDriver* imd = get();
|
|
|
|
if ( imd == 0 )
|
|
{
|
|
error = "Could not get datastore driver";
|
|
NebulaLog::log("ImM",Log::ERROR, error);
|
|
|
|
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: */
|
|
/* state is READY */
|
|
/* snapshot exists */
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
img = ipool->get(iid,true);
|
|
|
|
if ( img == 0 )
|
|
{
|
|
error = "Image does not exist";
|
|
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);
|
|
|
|
string img_tmpl;
|
|
string * drv_msg = format_message(img->to_xml(img_tmpl), ds_data);
|
|
|
|
imd->snapshot_flatten(iid, *drv_msg);
|
|
|
|
img->set_state(Image::LOCKED);
|
|
|
|
ipool->update(img);
|
|
|
|
img->unlock();
|
|
|
|
delete drv_msg;
|
|
|
|
return 0;
|
|
}
|
|
|