/ - Diff - OpenNebula - OpenNebula Development pages

         /**
          *  Closes any cloning operation on the image, updating the state if needed
          *    @param iid image id of the image to be released
          *    @param clone_img_id image id of the image that was being cloned
          *    @param iid image id of the image to that was being cloned
          *    @param clone_img_id the cloned image (id > 0) or market app (id =< 0)
          */
         void release_cloning_image(int iid, int clone_img_id);
-...
+         *
          * @return 0 if the image can be cloned, -1 otherwise
          */
         int can_clone_image(int             cloning_id,
                             ostringstream&  oss_error);
         int can_clone_image(int cloning_id, ostringstream&  oss_error);
         /**
          * Sets the state to CLONE for the given image
          *   @param new_id for the target image (new_id>0) or market app (new_id =<0)
          *   @param clonning_id the ID of the image to be cloned
          *   @param error if any
          *   @return 0 if siccess
          */
         int set_clone_state(int new_id, int cloning_id, std::string& error);
         /**
          *  Clone an existing image to the repository
-...
                         int cloning_id,
                         const string& ds_data,
                         string& error);
         /**
          *  Deletes an image from the repository and the DB. The Datastore image list
          *  is also updated

             return type;
         };
         /**
          * Returns the ID of the object originating this app
          *    @return the image, vmtemplate or flow id
          */
         int get_origin_id() const
+        {
             return origin_id;
         };
         //--------------------------------------------------------------------------
         // Set Marketplace app attributes
         //--------------------------------------------------------------------------
-...
         /**
          *  Origin of this App
          */
         std::string origin;
         int origin_id;
         // *************************************************************************
         // Constructor

     class MarketPlacePool;
     class MarketPlaceAppPool;
     class ImagePool;
     class DatastorePool;
     class ImageManager;
     class MarketPlaceManager : public MadManager, public ActionListener
+    {
-...
          *    @param m, monitor_period to monitor marketplaces
          *    @param mad, list of drivers for the manager
          */
         MarketPlaceManager( time_t t, time_t m, std::vector<const Attribute*>& mad);
         MarketPlaceManager(time_t t, time_t m, std::vector<const Attribute*>& mad);
         ~MarketPlaceManager(){};
         /**
          * Initializes internal pointers to other managers. Must be called when
          * all the other managers exist in Nebula::instance
          */
         void init_managers();
         /**
          *  This functions starts the associated listener thread, and creates a
          *  new thread for the MarketPlace Manager. This thread will wait in
          *  an action loop till it receives ACTION_FINALIZE.
-...
         /**
          *  Imports a new app into the marketplace. The marketplace app needs to
          *  include the ORIGIN attribute so the driver can locate the app. An
          *  include the ORIGIN_ID attribute so the driver can locate the app. An
          *  optional template maybe provided to export the app to a cloud.
          *    @param appid of the app
          *    @param market_data of the associated marketplace in XML format
-...
          */
         MarketPlaceAppPool * apppool;
     	/**
          *  Pointer to the image pool
          */
     	ImagePool *          ipool;
     	/**
          * Pointer to the image pool
          */
     	DatastorePool *      dspool;
     	/**
     	 *  Pointer to the Image Manger
          */
     	ImageManager *       imagem;
         /**
          *  Action engine for the Manager
          */

     #-------------------------------------------------------------------------------
     # Marketplace drivers, to be installed under $REMOTES_LOCATION/market
     #   - HTTP based marketplace, $REMOTES_LOCATION/market/http
     #   - S3-obeject based Image Repository, $REMOTES_LOCATION/datastore/fs
     #   - VMFS based Image Repository, $REMOTES_LOCATION/datastore/vmfs
     #   - LVM based Image Repository, $REMOTES_LOCATION/datastore/lvm
     #   - S3-obeject based marketplace, $REMOTES_LOCATION/market/s3
     #-------------------------------------------------------------------------------
     MARKETPLACE_DRIVER_HTTP_SCRIPTS="src/market_mad/remotes/http/import \

             puts str % ["VERSION", app['VERSION']]
             puts str % ["DESCRIPTION", app['DESCRIPTION']]
             puts str % ["SIZE", OpenNebulaHelper.unit_to_str(app['SIZE'].to_i,{},'M')]
             puts str % ["ORIGIN_ID", app['ORIGIN_ID']]
             puts str % ["FORMAT", app['FORMAT']]
             puts

     #!/usr/bin/env ruby
     # ---------------------------------------------------------------------------- #
     # 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.                                               #
     # ---------------------------------------------------------------------------- #
     ONE_LOCATION=ENV["ONE_LOCATION"]
     if !ONE_LOCATION
         RUBY_LIB_LOCATION="/usr/lib/one/ruby"
     else
         RUBY_LIB_LOCATION=ONE_LOCATION+"/lib/ruby"
         TEMPLATES_LOCATION=ONE_LOCATION+"/etc/occi_templates"
         CONF_LOCATION=ONE_LOCATION+"/etc"
     end
     $: << RUBY_LIB_LOCATION
     $: << RUBY_LIB_LOCATION+"/cloud"
     require 'marketplace/marketplace_client'
     require 'cli/command_parser'
     require 'cli/cli_helper'
     require 'rubygems'
     require 'json'
     USER_AGENT = "CLI"
+    #
     # Options
+    #
     DEFAULT_OPTIONS = [
         ENDPOINT = {
             :name => "server",
             :short => "-s url",
             :large => "--server url",
             :format => String,
             :description => "Marketplace endpoint"
         },
         USERNAME={
             :name => "username",
             :short => "-u name",
             :large => "--username name",
             :format => String,
             :description => "User name"
         },
         PASSWORD={
             :name => "password",
             :short => "-p pass",
             :large => "--password pass",
             :format => String,
             :description => "User password"
+        }
+    ]
     JSON_FORMAT={
         :name => "json",
         :short => "-j",
         :large => "--json",
         :description => "Show in JSON format"
+    }
+    #
     # Table
+    #
     TABLE = CLIHelper::ShowTable.new(nil, self) do
         column :ID, "Appliance", :size=>25 do |d|
             d["_id"]["$oid"]
         end
         column :NAME, "Name", :size=>50 do |d|
             d["name"]
         end
         column :PUBLISHER, "Publisher", :size=>15 do |d|
             d["publisher"]
         end
         default :ID, :NAME, :PUBLISHER
     end
+    #
     # Commands
+    #
     cmd=CommandParser::CmdParser.new(ARGV) do
         usage "`onemarket` <command> [<args>] [<options>]"
         set :option, DEFAULT_OPTIONS
+        #
         # List
+        #
         list_desc = <<-EOT.unindent
             List the available appliances in the Marketplace
         EOT
         command :list, list_desc, :options => JSON_FORMAT do
             client = Market::ApplianceClient.new(
                         options[:username],
                         options[:password],
                         options[:server],
                         USER_AGENT)
             response = client.list
             if CloudClient::is_error?(response)
                 [response.code.to_i, response.to_s]
             else
                 if options[:json]
                     [0,response.body]
                 else
                     array_list = JSON.parse(response.body)
                     TABLE.show(array_list['appliances'])
                 end
             end
         end
+        #
         # Create
+        #
         create_desc = <<-EOT.unindent
             Create a new appliance in the Marketplace
         EOT
         command :create, create_desc, :file do
             client = Market::ApplianceClient.new(
                         options[:username],
                         options[:password],
                         options[:server],
                         USER_AGENT)
             response = client.create(File.read(args[0]))
             if CloudClient::is_error?(response)
                 [response.code.to_i, response.to_s]
             else
                 [0, response.body]
             end
         end
+        #
         # Show
+        #
         show_desc = <<-EOT.unindent
             Show detailed information of a given appliance
         EOT
         command :show, show_desc, :id, :options => JSON_FORMAT do
             client = Market::ApplianceClient.new(
                         options[:username],
                         options[:password],
                         options[:server],
                         USER_AGENT)
             response = client.show(args[0])
             if CloudClient::is_error?(response)
                 [response.code.to_i, response.to_s]
             else
                 [0,response.body]
             end
         end
     end

     # ---------------------------------------------------------------------------- #
     # 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.                                               #
     # ---------------------------------------------------------------------------- #
     require 'uri'
     require 'cloud/CloudClient'
     require 'ostruct'
     module Market
         class Client
             def initialize(username, password, url, user_agent="Ruby")
                 @username = username
                 @password = password
                 url ||= 'http://marketplace.opennebula.systems/'
                 @uri = URI.parse(url)
                 @user_agent = "OpenNebula #{CloudClient::VERSION} (#{user_agent})"
                 @host = nil
                 @port = nil
                 if ENV['http_proxy']
                     uri_proxy  = URI.parse(ENV['http_proxy'])
                     @host = uri_proxy.host
                     @port = uri_proxy.port
                 end
             end
             def get(path)
                 req = Net::HTTP::Proxy(@host, @port)::Get.new(@uri.path + path)
                 do_request(req)
             end
             def post(path, body)
                 req = Net::HTTP::Proxy(@host, @port)::Post.new(@uri.path + path)
                 req.body = body
                 do_request(req)
             end
             private
             def do_request(req)
                 if @username && @password
                     req.basic_auth @username, @password
                 end
                 req['User-Agent'] = @user_agent
                 res = CloudClient::http_start(@uri, @timeout) do |http|
                     http.request(req)
                 end
                 res
             end
         end
         class ApplianceClient < Client
             def initialize(user, password, url, agent)
                 super(user, password, url, agent)
             end
             def list
                 get("/appliance")
             end
             def create(body)
                 post("/appliance", body)
             end
             def show(id)
                 get("/appliance/#{id}")
             end
         end
     end

         command="curl $curl_args"
         ;;
     ssh://*)
         # pseudo-url for ssh transfers ssh://user@host:path
         # -l to limit the bw
         ssh_src=$(echo $FROM | grep -Po '(?<=ssh://).+')
         ssh_arg=(${ssh_src//:/ })
         rmt_cmd="'cat ${ssh_arg[1]}'"
         command="ssh ${ssh_arg[0]} $rmt_cmd"
         ;;
     *)
         if [ ! -r $FROM ]; then
             echo "Cannot read from $FROM" >&2

     while IFS= read -r -d '' element; do
         XPATH_ELEMENTS[i++]="$element"
     done < <($XPATH     /DS_DRIVER_ACTION_DATA/IMAGE/SOURCE \
                         /DS_DRIVER_ACTION_DATA/DATASTORE/TEMPLATE/BRIDGE_LIST \
                         /DS_DRIVER_ACTION_DATA/DATASTORE/TEMPLATE/EXPORT_DIR \
                         /DS_DRIVER_ACTION_DATA/DATASTORE/BASE_PATH)
                         /DS_DRIVER_ACTION_DATA/DATASTORE/TEMPLATE/BRIDGE_LIST)
     unset i
     SRC="${XPATH_ELEMENTS[i++]}"
     BRIDGE_LIST="${XPATH_ELEMENTS[i++]}"
     EXPORT_DIR="${XPATH_ELEMENTS[i++]}"
     BASE_PATH="${XPATH_ELEMENTS[i++]}"
     EXPORT_DIR="${EXPORT_DIR-$BASE_PATH}"
     # -------------------- Convert image to qcow2 format ---------------------------
     # TODO:
     #   Export directories needs to be defined, probably in oned.conf
     #   BRIDGE_LIST needs to be handled
     #-------------------------------------------------------------------------------
     # Output image source and format
     #-------------------------------------------------------------------------------
     INFO_SCRIPT=$(cat <<EOF
     CHECKSUM=\$(${MD5SUM} ${SRC} | cut -f1 -d' ')
     SIZE=\$(${DU} -LBM ${SRC} | cut -f1)
     FORMAT=\$(${QEMU_IMG} info ${SRC} 2>/dev/null | grep -Po '(?<=file format: )\w+')
     echo "<CHECKSUM>\$CHECKSUM</CHECKSUM>"
     echo "<SIZE>\$SIZE</SIZE>"
     echo "<FORMAT>\$FORMAT</FORMAT>"
     EOF
+    )
     log "Removing $SRC from the image repository"
     if [ -n "$BRIDGE_LIST" ]; then
         HOST=`get_destination_host $ID`
         INFO=$(ssh_monitor_and_log "$HOST" "$INFO_SCRIPT" "Image info script" 2>&1)
         SRC="ssh://$HOST:$SRC"
     else
         INFO=$(monitor_and_log "$INFO_SCRIPT" "Image info script" 2>&1)
     fi
     INFO_STATUS=$?
     if [ "$INFO_STATUS" != "0" ]; then
         echo "$INFO"
         exit $INFO_STATUS
     fi
     exec_and_log "$QEMU_IMG convert -O qcow2 $SRC $SRC.export" \
     	"Error converting image to qcow2 format"
     echo "<IMPORT_INFO><IMPORT_SOURCE>$SRC</IMPORT_SOURCE> \
           $INFO \
           <DISPOSE>NO</DISPOSE></IMPORT_INFO>"
     echo "$SRC.export"

+    }
     #-------------------------------------------------------------------------------
     # Get file format using qemu-img
     #   @return string representation of the format, empty if error
     #-------------------------------------------------------------------------------
     function image_format {
         echo "$($QEMU_IMG info $1 2>/dev/null | grep -Po '(?<=file format: )\w+')"
+    }
     #-------------------------------------------------------------------------------
     # Generates an unique image hash. Requires ID to be set
     #   @return hash for the image (empty if error)
     #-------------------------------------------------------------------------------

             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());
                 NebulaLog::log("ImM", Log::ERROR, "Release cloning image"
                     " in wrong state");
                 break;
+        }
-...
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     int ImageManager::can_clone_image(  int             cloning_id,
                                         ostringstream&  oss_error)
     int ImageManager::can_clone_image(int cloning_id, ostringstream&  oss_error)
+    {
         Image *       img;
-...
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     int ImageManager::clone_image(int   new_id,
                                   int   cloning_id,
                                   const string& ds_data,
                                   string& error)
     int ImageManager::set_clone_state(int new_id, int cloning_id, std::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);
         int     rc  = 0;
         Image * img = ipool->get(cloning_id, true);
         if (img == 0)
+        {
-...
+                }
                 ipool->update(img);
                 img->unlock();
             break;
                 break;
             case Image::USED:
             case Image::CLONE:
                 img->inc_cloning(new_id);
                 ipool->update(img);
                 img->unlock();
             break;
                 break;
             case Image::USED_PERS:
             case Image::INIT:
-...
             case Image::ERROR:
             case Image::DELETE:
             case Image::LOCKED:
                 oss << "Cannot clone image in state: "
                     << Image::state_to_str(img->get_state());
                 error = "Cannot clone image in current state";
                 rc    = -1;
                 break;
+        }
                 error = oss.str();
                 img->unlock();
                 return -1;
             break;
         img->unlock();
         return rc;
+    }
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     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;
+        }
         if ( set_clone_state(new_id, cloning_id, error) == -1 )
+        {
             return -1;
+        }
         img = ipool->get(new_id,true);
         if (img == 0) //TODO: Rollback cloning counter
         if (img == 0)
+        {
             release_cloning_image(cloning_id, new_id);
             error = "Target image deleted during cloning operation";
             return -1;
+        }

         type = IMAGE;
         //Known attributes
         //ORIGIN
         //ORIGIN_ID
         //DESCRIPTION
         //APPTEMPLATE64
         //PUBLISHER
         //VERSION
         erase_template_attribute("ORIGIN", origin);
         if (origin.empty())
         if (!get_template_attribute("ORIGIN_ID", origin_id))
+        {
             goto error_origin;
+        }
         remove_template_attribute("ORIGIN_ID");
         get_template_attribute("DESCRIPTION", description);
         get_template_attribute("APPTEMPLATE64", apptemplate64);
-...
         return insert_replace(db, false, error_str);
     error_origin:
         error_str = "Missing ORIGIN for the MARKETPLACEAPP";
         error_str = "Missing ORIGIN_ID for the MARKETPLACEAPP";
         NebulaLog::log("MKP", Log::ERROR, error_str);
         return -1;
+    }
-...
     			"<GNAME>"          << gname         << "</GNAME>" <<
     			"<DATE>"           << date          << "</DATE>" <<
     			"<NAME>"           << name          << "</NAME>" <<
                 "<ORIGIN>"         << origin        << "</ORIGIN>" <<
                 "<ORIGIN_ID>"      << origin_id     << "</ORIGIN_ID>" <<
                 "<SOURCE>"         << source        << "</SOURCE>" <<
                 "<CHECKSUM>"       << checksum      << "</CHECKSUM>" <<
                 "<SIZE>"           << size_mb       << "</SIZE>" <<
-...
         rc += xpath(gname,        "/MARKETPLACEAPP/GNAME", "not_found");
         rc += xpath(name,         "/MARKETPLACEAPP/NAME", "not_found");
         rc += xpath(date,         "/MARKETPLACEAPP/DATE", -1);
         rc += xpath(source,       "/MARKETPLACEAPP/SOURCE","not_found");
         rc += xpath(origin,       "/MARKETPLACEAPP/ORIGIN","not_found");
         rc += xpath(source,       "/MARKETPLACEAPP/SOURCE", "not_found");
         rc += xpath(origin_id,    "/MARKETPLACEAPP/ORIGIN_ID", -1);
         rc += xpath(istate,       "/MARKETPLACEAPP/STATE", -1);
         rc += xpath(itype,        "/MARKETPLACEAPP/TYPE",  -1);
         rc += xpath(description,  "/MARKETPLACEAPP/DESCRIPTION", "not_found");

                 std::vector<const Attribute*>& _mads):
             MadManager(_mads),
             timer_period(_timer_period),
             monitor_period(_monitor_period)
             monitor_period(_monitor_period),
             imagem(0)
+    {
         Nebula& nd = Nebula::instance();
         mppool  = nd.get_marketpool();
         apppool = nd.get_apppool();
         dspool  = nd.get_dspool();
         ipool   = nd.get_ipool();
         am.addListener(this);
     };
-...
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     void MarketPlaceManager::init_managers()
+    {
         Nebula& nd = Nebula::instance();
         imagem = nd.get_imagem();
+    }
     /* -------------------------------------------------------------------------- */
     /* -------------------------------------------------------------------------- */
     int MarketPlaceManager::start()
+    {
         int            rc;

     #include "MarketPlaceAppPool.h"
     #include "MarketPlaceManagerDriver.h"
     #include "Image.h"
     #include "Datastore.h"
     #include "ImageManager.h"
     #include "NebulaLog.h"
     #include "Nebula.h"
-...
             const std::string& market_data,
             std::string&       err)
+    {
         std::string      app_data;
         std::string app_data, image_data, ds_data;
     	std::string * msg;
     	Image * image;
     	Datastore * ds;
     	int ds_id;
         const MarketPlaceManagerDriver* mpmd = get();
         if ( mpmd == 0 )
+        {
             err = "Error getting MarketPlaceManagerDriver";
             return -1;
+        }
         MarketPlaceApp * app = apppool->get(appid, true);
         if ( app == 0 )
-...
         app->to_xml(app_data);
         app->unlock();
         MarketPlaceApp::MarketPlaceAppType type = app->get_type();
         std::string * msg = format_message(app_data, market_data, "");
     	int app_id    = app->get_oid();
         int origin_id = app->get_origin_id();
         const MarketPlaceManagerDriver* mpmd = get();
         app->unlock();
         if ( mpmd == 0 )
         switch (type)
+        {
             err = "Error getting MarketPlaceManagerDriver";
             return -1;
             case MarketPlaceApp::IMAGE:
                 image = ipool->get(origin_id, true);
     			if ( image == 0 )
+    			{
     				err = "Image does not exist.";
     				return -1;
+    			}
                 image->to_xml(image_data);
                 ds_id = image->get_ds_id();
                 image->unlock();
                 ds = dspool->get(ds_id, true);
     			if ( ds == 0 )
+    			{
     				err = "Image datastore no longer exists.";
     				return -1;
+    			}
                 ds->to_xml(ds_data);
                 ds->unlock();
     			if (imagem->set_clone_state(-app_id, origin_id, err) != 0)
+    			{
     				return -1;
+    			}
     			break;
             case MarketPlaceApp::VMTEMPLATE:
             case MarketPlaceApp::FLOW:
             case MarketPlaceApp::UNKNOWN:
                 err = "Marketplace app type not supported.";
                 return -1;
+        }
         msg = format_message(app_data, market_data, image_data + ds_data);
         mpmd->importapp(appid, *msg);
         delete msg;

         end
         ############################################################################
         # Image Manager Protocol Actions (generic implementation)
         # Import a marketplace app into the marketplace. This is a two step process:
         #   1- The associated datastore_mad/export script is invoked to generate
         #      a file representation of the app.
         #   2- The resulting file path is used to import it into the marketplace
         #      invoking marketplace_mad/import.
         ############################################################################
         def import(id, drv_message)
             xml = decode(drv_message)
-...
             end
             type   = xml['MARKETPLACEAPP/TYPE']
             origin = xml['MARKETPLACEAPP/ORIGIN']
             origin = xml['MARKETPLACEAPP/ORIGIN_ID']
             mp_mad = xml['MARKETPLACE/MARKET_MAD']
             if type.nil? || origin.nil? || mp_mad.nil?
                 failure(:import, id,"Wrong driver message format")
                 failure(:import, id, "Wrong driver message format")
                 return
             end
             case OpenNebula::MarketPlaceApp::MARKETPLACEAPP_TYPES[type.to_i]
             #-----------------------------------------------------------------------
             #  Export origin to a path
             # Export marketplace origin to a file path, IMAGE
             #-----------------------------------------------------------------------
             case OpenNebula::MarketPlaceApp::MARKETPLACEAPP_TYPES[type.to_i]
               when "IMAGE" then
                 if ( origin =~ /\d+$/ )
                     # Get the associated datastore ID
                     image = OpenNebula::Image.new_with_id(origin, @one)
                     rc    = image.info
                     if OpenNebula.is_error?(rc)
                         failure(:import, id, "Cannot find information for image "\
                                 "#{origin}: #{rc.to_str()}")
                         return
                     end
                     ds_id = image['DATASTORE_ID']
                     if ds_id.nil?
                         failure(:import, id, "Cannot find datastore for image #{origin}")
                         return
                     end
                     ds = OpenNebula::Datastore.new_with_id(ds_id, @one)
                     rc = ds.info
                     if OpenNebula.is_error?(rc)
                         failure(:import, id, "Datastore #{ds_id} not found: #{rc}")
                         return
                     end
                     ds_mad = ds['DS_MAD']
                     if ds_mad.nil?
                         failure(:import, id, "Cannot find datastore driver")
                         return
                     end
                     #Execute export action from Datastore
                     ds_msg   = "<DS_DRIVER_ACTION_DATA>"\
                                "#{image.to_xml}"\
                                "#{ds.to_xml}"\
                                "</DS_DRIVER_ACTION_DATA>"
                     ds_msg64 = Base64::strict_encode64(ds_msg)
                     result, info = do_action(id, nil, ds_mad, :export,
                         "#{ds_msg64} #{id}", false)
                     if ( result == RESULT[:failure] )
                         failure(:import, id, "Error exporting image to file: #{info}")
                         return
                     end
                     source = info
                 elsif ( source =~ /\/.+|https?:\/\// )
                     source = origin
                 else
                     failure(:import, id, "Origin is not a valid ID, path or URL")
             when "IMAGE" then
                 # ------------ Execute export action from Datastore ----------------
                 ds_mad = xml['DATASTORE/DS_MAD']
                 if ds_mad.nil?
                     failure(:import, id, "Wrong driver message format")
                     return
                 end
               else # Only IMAGE type is supported
                     failure(:import, id, "Type #{apptype} not supported")
                 ds_msg = "<DS_DRIVER_ACTION_DATA>"\
                          "#{xml.element_xml('IMAGE')}"\
                          "#{xml.element_xml('DATASTORE')}"\
                          "</DS_DRIVER_ACTION_DATA>"
                 ds_msg64 = Base64::strict_encode64(ds_msg)
                 result, info = do_action(id, nil, ds_mad, :export,
                     "#{ds_msg64} #{id}", false)
                 if ( result == RESULT[:failure] )
                     failure(:import, id, "Error exporting image to file: #{info}")
                     return
                 end
                 info_doc = OpenNebula::XMLElement.new
                 info_doc.initialize_xml(info, 'IMPORT_INFO')
             #-----------------------------------------------------------------------
             # Only IMAGE type is supported
             #-----------------------------------------------------------------------
             else
                 failure(:import, id, "Type #{apptype} not supported")
                 return
             end
             # --------------- Import image app into the marketplace ----------------
             xml.add_element('/MARKET_DRIVER_ACTION_DATA',
                 'IMPORT_SOURCE' => "#{source}")
                             'IMPORT_SOURCE' => "#{info_doc['IMPORT_SOURCE']}",
                             'CHECKSUM'      => "#{info_doc['CHECKSUM']}",
                             'SIZE'          => "#{info_doc['SIZE']}",
                             'FORMAT'        => "#{info_doc['FORMAT']}",
                             'DISPOSE'       => "#{info_doc['DISPOSE']}")
             mp_msg64 = Base64::strict_encode64(xml.to_xml)
             result, info = do_action(id, mp_mad, nil, :import, "#{mp_msg64} #{id}",
-...
             result, info = get_info_from_execution(rc)
             info = Base64::strict_encode64(info) if encode
             info = Base64::strict_encode64(info) if encode && result != RESULT[:failure]
             return result, info
         end

     DRIVER_PATH=$(dirname $0)
     source ${DRIVER_PATH}/../../datastore/libfs.sh
     XPATH_PATH="${DRIVER_PATH}/../../datastore"
     UTILS_PATH="${DRIVER_PATH}/../../datastore"
     # -------- Get arguments from OpenNebula core ------------
     DRV_ACTION=$1
     ID=$2
     XPATH="$XPATH_PATH/xpath.rb -b $DRV_ACTION"
     XPATH="$UTILS_PATH/xpath.rb -b $DRV_ACTION"
     unset i XPATH_ELEMENTS
     while IFS= read -r -d '' element; do
         XPATH_ELEMENTS[i++]="$element"
     done < <($XPATH     /MARKET_DRIVER_ACTION_DATA/IMPORT_SOURCE \
                         /MARKET_DRIVER_ACTION_DATA/FORMAT \
                         /MARKET_DRIVER_ACTION_DATA/DISPOSE \
                         /MARKET_DRIVER_ACTION_DATA/SIZE \
                         /MARKET_DRIVER_ACTION_DATA/CHECKSUM \
                         /MARKET_DRIVER_ACTION_DATA/MARKETPLACE/TEMPLATE/BASE_URL \
                         /MARKET_DRIVER_ACTION_DATA/MARKETPLACE/TEMPLATE/BRIDGE_LIST \
                         /MARKET_DRIVER_ACTION_DATA/MARKETPLACE/TEMPLATE/PUBLIC_DIR)
     unset i
     IMPORT_SOURCE="${XPATH_ELEMENTS[i++]}"
     FORMAT="${XPATH_ELEMENTS[i++]}"
     DISPOSE="${XPATH_ELEMENTS[i++]}"
     SIZE="${XPATH_ELEMENTS[i++]}"
     CHECKSUM="${XPATH_ELEMENTS[i++]}"
     BASE_URL="${XPATH_ELEMENTS[i++]}"
     BRIDGE_LIST="${XPATH_ELEMENTS[i++]}"
     PUBLIC_DIR="${XPATH_ELEMENTS[i++]}"
     # -------- Copy source to public folder an generarte App data ------------
-...
     DST_PATH="${PUBLIC_DIR}/${APPNAME}"
     SOURCE="${BASE_URL}/${APPNAME}"
     if [ ! -f ${IMPORT_SOURCE} ]; then
         log_error "File ${IMPORT_SOURCE} does not exits"
         exit -1
     fi
     if [ -n "$BRIDGE_LIST" ]; then
         DST_HOST=`get_destination_host $ID`
         CP_CMD="$UTILS_PATH/downloader.sh ${IMPORT_SOURCE} -"
     CHECKSUM=$(${MD5SUM} ${IMPORT_SOURCE} | cut -f1 -d' ')
         exec_and_log "eval $CP_CMD | $SSH ${DST_HOST} $DD of=${DST_PATH} bs=64k" \
                      "Error dumping ${IMPORT_SOURCE} to ${DST_HOST}:${DST_PATH}"
     SIZE=$(fs_size ${IMPORT_SOURCE})
         #if [ "${DISPOSE}" = "YES" ]; then
         #TODO This should call a ds operation
         #fi
     else
         CP_CMD="$UTILS_PATH/downloader.sh ${IMPORT_SOURCE} ${DST_PATH}"
         exec_and_log "$CP_CMD" "Error copying ${IMPORT_SOURCE} to ${DST_PATH}"
     if [ "$SIZE" = "0" ]; then
         log_error "Cannot determine size for ${IMPORT_SOURCE}"
         exit -1
         if [ "${DISPOSE}" = "YES" ]; then
         #TODO This should call a ds operation
             exec_and_log "$RM ${IMPORT_SOURCE}" "Error removing ${IMPORT_SOURCE}"
         fi
     fi
     exec_and_log "$CP ${IMPORT_SOURCE} ${DST_PATH}" \
         "Error copying ${IMPORT_SOURCE} to ${DST_PATH}. ${IMPORT_SOURCE} not removed"
     exec_and_log "$RM ${IMPORT_SOURCE}" "Error removing ${IMPORT_SOURCE}"
     RESPONSE=$(cat << EOF
     SOURCE="$SOURCE"
     CHECKSUM="$CHECKSUM"
     SIZE="$SIZE"
     FORMAT="$FORMAT"
     EOF
+    )

         lcm->init_managers();
         marketm->init_managers();
         // ---- Start the Request Manager ----
         rc = rm->start();

OpenNebula

Revision ade6513a