image-resize-4.2.patch - OpenNebula - OpenNebula Development pages

          *         occurred describing the error.
          *  @result 0 on success
          */
          int stat_image(Template* img_tmpl, const string& ds_tmpl, string& res);
         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);
          /**
           *  Trigger a monitor action for the datastore.

          *    @param drv_msg xml data for the mad operation.
          */
         void monitor(int oid, const string& drv_msg) const;
         /**
          *  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);
     };
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     #endif

             :log     => "LOG",
             :stat    => "STAT",
             :clone   => "CLONE",
             :monitor => "MONITOR"
             :monitor => "MONITOR",
             :resize => "RESIZE"
+        }
         # Register default actions for the protocol
-...
                     ACTION[:rm]      => nil,
                     ACTION[:mkfs]    => nil,
                     ACTION[:clone]   => nil,
                     ACTION[:monitor] => nil
                     ACTION[:monitor] => nil,
                     ACTION[:resize]  => nil
+                }
             }.merge!(options)
-...
             register_action(ACTION[:stat].to_sym, method("stat"))
             register_action(ACTION[:clone].to_sym, method("clone"))
             register_action(ACTION[:monitor].to_sym, method("monitor"))
             register_action(ACTION[:resize].to_sym,method("resize"))
         end
         ############################################################################
-...
             do_image_action(id, ds, :monitor, "#{drv_message} #{id}", true)
         end
         def resize(id, drv_message)
             ds = get_ds_type(drv_message)
             do_image_action(id, ds, :resize, "#{drv_message} #{id}")
         end
         private
         def is_available?(ds, id, action)

         return rc;
+    }
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     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 &&
              img->get_state() != Image::USED &&
              img->get_state() != Image::USED_PERS )
+        {
             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;
+        }
         if ( image->get_running() == 0 ) {
             image->set_state(Image::READY);
         } else if ( image->isPersistent() ) {
             image->set_state(Image::USED_PERS);
         } else {
             image->set_state(Image::USED);
+        }
         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;
+    }
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     void ImageManagerDriver::protocol(const string& message) const
-...
+        {
             monitor_action(is, dspool, id, result);
+        }
         else if ( action == "RESIZE" )
+        {
             resize_action(is, ipool, id, result);
+        }
         else if (action == "LOG")
+        {
             getline(is,info);

         xmlrpc_c::methodPtr image_enable(new ImageEnable());
         xmlrpc_c::methodPtr image_chtype(new ImageChangeType());
         xmlrpc_c::methodPtr image_clone(new ImageClone());
         xmlrpc_c::methodPtr image_resize(new ImageResize());
         // Chown Methods
         xmlrpc_c::methodPtr vm_chown(new VirtualMachineChown());
-...
         RequestManagerRegistry.addMethod("one.image.chtype", image_chtype);
         RequestManagerRegistry.addMethod("one.image.clone", image_clone);
         RequestManagerRegistry.addMethod("one.image.rename", image_rename);
         RequestManagerRegistry.addMethod("one.image.resize", image_resize);
         RequestManagerRegistry.addMethod("one.imagepool.info", imagepool_info);

         success_response(new_id, att);
+    }
     /* ------------------------------------------------------------------------- */
     /* ------------------------------------------------------------------------- */
     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);
+    }

         map<string, float> ds_request;
         string ds_id;
         int    size;
         int    size, images;
         tmpl->get("DATASTORE", ds_id);
-...
             return false;
+        }
         ds_request.insert(make_pair("IMAGES",1));
         ds_request.insert(make_pair("SIZE",  size));
         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));
         return check_quota(ds_id, ds_request, default_quotas, error);
+    }
-...
         map<string, float> ds_request;
         string ds_id;
         int    size;
         int    size, images;
         tmpl->get("DATASTORE", ds_id);
-...
             return;
+        }
         ds_request.insert(make_pair("IMAGES",1));
         ds_request.insert(make_pair("SIZE",  size));
         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));
         del_quota(ds_id, ds_request);
+    }
+    -