OpenNebula

    int stat_image(Template* img_tmpl, const string& ds_tmpl, string& res);

    /**

     *  Resizes the image

     *    @param iid id of image

     *    @param new_size new size of the image in MB

     *    @return 0 on success

     */

    int resize_image(int iid, int new_size, const string& ds_data, string& error);

    /**

     *  Sends a resize request to the MAD: "RESIZE IMAGE_ID PATH"

     *    @param oid the image id.

     *    @param drv_msg xml data for the mad operation.

     */

    void resize(int oid, const string& drv_msg) const;

class ImageResize : public RequestManagerImage

{

public:

    ImageResize():

        RequestManagerImage("ImageResize",

                "Changes the size of an image",

                "A:sii"){};

    ~ImageResize(){};

    void request_execute(xmlrpc_c::paramList const& _paramList,

                         RequestAttributes& att);

};

/* -------------------------------------------------------------------------- */

/* -------------------------------------------------------------------------- */

        :cp     => "CP",

        :rm     => "RM",

        :mkfs   => "MKFS",

        :log    => "LOG",

        :stat   => "STAT",

        :clone  => "CLONE",

        :resize => "RESIZE"

                ACTION[:stat]  => nil,

                ACTION[:cp]    => nil,

                ACTION[:rm]    => nil,

                ACTION[:mkfs]  => nil,

                ACTION[:clone] => nil,

                ACTION[:resize]=> nil

        register_action(ACTION[:resize].to_sym,method("resize"))

    def resize(id, drv_message)

        ds = get_ds_type(drv_message)

        do_image_action(id, ds, :resize, "#{drv_message} #{id}")

    end

/* -------------------------------------------------------------------------- */

/* -------------------------------------------------------------------------- */

int ImageManager::resize_image(int   iid,

                               int   new_size,

                               const string& ds_data,

                               string& error)

{

    const ImageManagerDriver* imd = get();

    ostringstream oss;

    Image *       img;

    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 = "Cannot resize image, it does not exist";

        return -1;

    }

    if (img->get_state() != Image::READY )

    {

        oss << "Cannot resize image in state: "

            << Image::state_to_str(img->get_state());

        error = oss.str();

        img->unlock();

        return -1;

    }

    img->set_state(Image::LOCKED);

    img->set_size(new_size);  

    ipool->update(img);

    drv_msg = format_message(img->to_xml(img_tmpl), ds_data);

    imd->resize(img->get_oid(), *drv_msg);

    oss << "Resizing image " << img->get_path()

        <<" to " << img->get_size()

        << "Mb (type: " <<  img->get_fstype() << ")";

    NebulaLog::log("ImM", Log::INFO, oss);

    img->unlock();

    delete drv_msg;

    return 0;

}

void ImageManagerDriver::resize(int oid, const string& drv_msg) const

{

    ostringstream os;

    os << "RESIZE " << oid << " " << drv_msg << endl;

    write(os);

}

/* -------------------------------------------------------------------------- */

static void resize_action(istringstream& is, 

                      ImagePool*     ipool, 

                      int            id, 

                      const string&  result)

{

    string  info;

    Image * image;

    ostringstream oss;

    image = ipool->get(id, true);

    if ( image == 0 )

    {

        return;

    }

    if ( result == "FAILURE" )

    {

        goto error;

    }

    image->set_state(Image::READY);

    ipool->update(image);

    image->unlock();

    NebulaLog::log("ImM", Log::INFO, "Image successfully resized.");

    return;

error:

    oss << "Error resizing image";

    getline(is, info);

    if (!info.empty() && (info[0] != '-'))

    {

        oss << ": " << info;

    }

    NebulaLog::log("ImM", Log::ERROR, oss);

    image->set_template_error_message(oss.str());

    image->set_state(Image::ERROR);

    ipool->update(image);

    image->unlock();

    return;

}

/* -------------------------------------------------------------------------- */

    else if ( action == "RESIZE" )

    {

        resize_action(is, ipool, id, result);

    }

    xmlrpc_c::methodPtr image_resize(new ImageResize());

    RequestManagerRegistry.addMethod("one.image.update", image_update);

    RequestManagerRegistry.addMethod("one.image.resize", image_resize);

/* ------------------------------------------------------------------------- */

/* ------------------------------------------------------------------------- */

void ImageResize::request_execute(xmlrpc_c::paramList const& paramList,

                                      RequestAttributes& att)

{

    int     id   = xmlrpc_c::value_int(paramList.getInt(1));

    int     new_size = xmlrpc_c::value_int(paramList.getInt(2));

    int     rc, ds_id, size, uid, gid;

    string  error_str, ds_data;

    Template        img_usage;

    Image *         img;

    Datastore *     ds;

    Nebula&         nd     = Nebula::instance();

    ImageManager *  imagem = nd.get_imagem();

    DatastorePool * dspool = nd.get_dspool();

    if ( basic_authorization(id, att) == false )

    {

        return;

    }

    // ------------------------- Get Image info -------------------------

    img = static_cast<Image *>(pool->get(id,true));

    if ( img == 0 )

    {

        failure_response(NO_EXISTS,

                get_error(object_name(auth_object),id),

                att);

        return;

    }

    ds_id   = img->get_ds_id();

    size    = img->get_size();

    uid     = img->get_uid();

    gid     = img->get_gid();

    img->unlock();

    // ------------------------- Get Datastore info ----------------------------

    ds = dspool->get(ds_id, true);

    if ( ds == 0 )

    {

        failure_response(NO_EXISTS,

                get_error(object_name(PoolObjectSQL::DATASTORE), ds_id),

                att);

        return;

    }

    ds->to_xml(ds_data);

    ds->unlock();

    // -------------------------- Check and Update Quotas  ----------------------------

    // Check quota for owner of the image, not the request caller

    RequestAttributes quota_att(uid, gid, att);

    img_usage.add("DATASTORE", ds_id);

    img_usage.add("IMAGES", 0);  // Don't update images count

    if ( new_size > size )

    {

        // Update quota usage to extended size

        img_usage.add("SIZE", new_size - size);

        if ( quota_authorization(&img_usage, Quotas::DATASTORE, quota_att) == false )

        {

             // Over quota

             return;

        }

    }

    rc = imagem->resize_image(id, new_size, ds_data, error_str);

    if( rc < 0 )

    {

        if ( new_size > size ) {

            // Rollback quota update

            quota_rollback(&img_usage, Quotas::DATASTORE, quota_att);

        }

        failure_response(INTERNAL, request_error(error_str,""), att);

        return;

    }

    // If disk is being shrinked, reduce quota usage

    if ( new_size < size ) 

    {

        img_usage.add("SIZE", size - new_size);

        quota_rollback(&img_usage, Quotas::DATASTORE, quota_att);

    }

    success_response(id, att);

}

    int    size, images;

    if ( tmpl->get("IMAGES", images) == false )

    {

        // Increment image count by default

        images = 1;

    }

    ds_request.insert(make_pair("IMAGES", images));

    ds_request.insert(make_pair("SIZE",   size));

    int    size, images;

    if ( tmpl->get("IMAGES", images) == false )

    {

        // Decrement image count by default

        images = 1;

    }

    ds_request.insert(make_pair("IMAGES", images));

    ds_request.insert(make_pair("SIZE",   size));