OpenNebula

    cwd+'/src/vm_template',

    'src/vm_template/SConstruct',

        CLUSTER,

        TEMPLATE

#include "VMTemplatePool.h"

    VMTemplatePool * get_tpool()

    {

        return tpool;

    };

    Nebula():nebula_configuration(0),db(0),vmpool(0),hpool(0),vnpool(0),

        upool(0),ipool(0),cpool(0),tpool(0),lcm(0),vmm(0),im(0),tm(0),dm(0),

        rm(0),hm(0),authm(0)

        if ( tpool != 0)

        {

            delete tpool;

        }

    VMTemplatePool     * tpool;

#include "VMTemplatePool.h"

        VMTemplatePool     *    _tpool,

            ipool(_ipool),cpool(_cpool),tpool(_tpool),port(_port),socket_fd(-1),

     *  Pointer to the Cluster Pool, to access clusters

     *  Pointer to the Template Pool, to access templates

     */

    VMTemplatePool     *    tpool;

    /**

    /*                            Template Interface                          */

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

    class TemplateAllocate: public xmlrpc_c::method

    {

    public:

        TemplateAllocate(

            VMTemplatePool * _tpool,

            UserPool * _upool):

                tpool(_tpool),

                upool(_upool)

        {

            _signature="A:ss";

            _help="Allocates a template in the pool";

        };

        ~TemplateAllocate(){};

        void execute(

            xmlrpc_c::paramList const& paramList,

            xmlrpc_c::value *   const  retvalP);

    private:

        VMTemplatePool * tpool;

        UserPool *       upool;

    };

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

    class TemplateDelete: public xmlrpc_c::method

    {

    public:

        TemplateDelete(VMTemplatePool * _tpool,

                       UserPool *       _upool):

                            tpool(_tpool),

                            upool(_upool)

        {

            _signature="A:si";

            _help="Deletes a Template";

        };

        ~TemplateDelete(){};

        void execute(

            xmlrpc_c::paramList const& paramList,

            xmlrpc_c::value *   const  retvalP);

    private:

        VMTemplatePool * tpool;

        UserPool  *      upool;

    };

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

    class TemplateInfo: public xmlrpc_c::method

    {

    public:

        TemplateInfo(VMTemplatePool * _tpool,

                     UserPool *       _upool):

                      tpool(_tpool),

                      upool(_upool)

        {

            _signature="A:si";

            _help="Returns information for a Template";

        };

        ~TemplateInfo(){};

        void execute(

            xmlrpc_c::paramList const& paramList,

            xmlrpc_c::value *   const  retvalP);

    private:

        VMTemplatePool * tpool;

        UserPool  *      upool;

    };

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

    class TemplateUpdate: public xmlrpc_c::method

    {

    public:

        TemplateUpdate(VMTemplatePool * _tpool,

                       UserPool *       _upool):

                        tpool(_tpool),

                        upool(_upool)

        {

            _signature="A:siss";

            _help="Modifies Template attribute";

        };

        ~TemplateUpdate(){};

        void execute(

            xmlrpc_c::paramList const& paramList,

            xmlrpc_c::value *   const  retvalP);

    private:

        VMTemplatePool * tpool;

        UserPool  *      upool;

    };

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

    class TemplateRemoveAttribute: public xmlrpc_c::method

    {

    public:

        TemplateRemoveAttribute(VMTemplatePool * _tpool,

                             UserPool *          _upool):

                        tpool(_tpool),

                        upool(_upool)

        {

            _signature="A:sis";

            _help="Removes Template attribute";

        };

        ~TemplateRemoveAttribute(){};

        void execute(

            xmlrpc_c::paramList const& paramList,

            xmlrpc_c::value *   const  retvalP);

    private:

        VMTemplatePool * tpool;

        UserPool  *      upool;

    };

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

    class TemplatePublish: public xmlrpc_c::method

    {

    public:

        TemplatePublish(VMTemplatePool * _tpool,

                     UserPool *          _upool):

                        tpool(_tpool),

                        upool(_upool)

        {

            _signature="A:sib";

            _help="Publish/Unpublish the Template";

        };

        ~TemplatePublish(){};

        void execute(

            xmlrpc_c::paramList const& paramList,

            xmlrpc_c::value *   const  retvalP);

    private:

        VMTemplatePool * tpool;

        UserPool  *      upool;

    };

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

    class TemplatePoolInfo: public xmlrpc_c::method

    {

    public:

        TemplatePoolInfo(

            VMTemplatePool * _tpool,

            UserPool * _upool):

                tpool(_tpool),

                upool(_upool)

        {

            _signature="A:sii";

            _help="Returns the template pool";

        };

        ~TemplatePoolInfo(){};

        void execute(

            xmlrpc_c::paramList const& paramList,

            xmlrpc_c::value *   const  retvalP);

    private:

        VMTemplatePool * tpool;

        UserPool *       upool;

    };

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

//    int select_cb(void *nil, int num, char **values, char **names);

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

/* Copyright 2002-2011, OpenNebula Project Leads (OpenNebula.org)             */

/*                                                                            */

/* 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.                                             */

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

#ifndef VMTEMPLATE_H_

#define VMTEMPLATE_H_

#include "PoolObjectSQL.h"

#include "VirtualMachineTemplate.h"

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

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

/**

 *  The VMTemplate class.

 */

class VMTemplate : public PoolObjectSQL

{

public:

    /**

     *  Function to write a VMTemplate on an output stream

     */

    friend ostream& operator<<(ostream& os, VMTemplate& u);

    /**

     * Function to print the VMTemplate object into a string in XML format

     *  @param xml the resulting XML string

     *  @return a reference to the generated string

     */

    string& to_xml(string& xml) const;

    /**

     *  Returns true if the object is public

     *     @return true if the Virtual Network is public

     */

    bool isPublic()

    {

        return (public_template == 1);

    };

    /**

     *  Publish or unpublish an object

     *    @param pub true to publish the object

     *    @return 0 on success

     */

    bool publish(bool pub)

    {

        if (pub == true)

        {

            public_template = 1;

        }

        else

        {

            public_template = 0;

        }

        return true;

    };

    // ------------------------------------------------------------------------

    // Template Contents

    // ------------------------------------------------------------------------

    /**

     *  Gets the values of a template attribute

     *    @param name of the attribute

     *    @param values of the attribute

     *    @return the number of values

     */

    int get_template_attribute(

        string& name,

        vector<const Attribute*>& values) const

    {

        return template_contents->get(name,values);

    };

    /**

     *  Gets the values of a template attribute

     *    @param name of the attribute

     *    @param values of the attribute

     *    @return the number of values

     */

    int get_template_attribute(

        const char *name,

        vector<const Attribute*>& values) const

    {

        string str=name;

        return template_contents->get(str,values);

    };

    /**

     *  Gets a string based attribute

     *    @param name of the attribute

     *    @param value of the attribute (a string), will be "" if not defined

     */

    void get_template_attribute(

        const char *    name,

        string&         value) const

    {

        string str=name;

        template_contents->get(str,value);

    };

    /**

     *  Gets a string based attribute

     *    @param name of the attribute

     *    @param value of the attribute (an int), will be 0 if not defined

     */

    void get_template_attribute(

        const char *    name,

        int&            value) const

    {

        string str=name;

        template_contents->get(str,value);

    };

    /**

     *  Removes an attribute

     *    @param name of the attribute

     */

    int remove_template_attribute(const string&   name)

    {

        return template_contents->erase(name);

    };

    /**

     *  Adds a new attribute to the template (replacing it if

     *  already defined), the object's mutex SHOULD be locked

     *    @param name of the new attribute

     *    @param value of the new attribute

     *    @return 0 on success

     */

    int replace_template_attribute(

        const string& name,

        const string& value)

    {

        SingleAttribute * sattr;

        template_contents->erase(name);

        sattr = new SingleAttribute(name,value);

        template_contents->set(sattr);

        return 0;

    };

private:

    // -------------------------------------------------------------------------

    // Friends

    // -------------------------------------------------------------------------

    friend class VMTemplatePool;

    // -------------------------------------------------------------------------

    // VMTemplate Attributes

    // -------------------------------------------------------------------------

    /**

     *  Owner's name

     */

    string      user_name;

    /**

     *  The Virtual Machine template, holds the VM attributes.

     */

    VirtualMachineTemplate* template_contents;

    /**

     *  Public scope of the VMTemplate

     */

    int         public_template;

    // *************************************************************************

    // DataBase implementation (Private)

    // *************************************************************************

    /**

     *  Execute an INSERT or REPLACE Sql query.

     *    @param db The SQL DB

     *    @param replace Execute an INSERT or a REPLACE

     *    @return 0 one success

     */

    int insert_replace(SqlDB *db, bool replace);

    /**

     *  Bootstraps the database table(s) associated to the VMTemplate

     */

    static void bootstrap(SqlDB * db)

    {

        ostringstream oss(VMTemplate::db_bootstrap);

        db->exec(oss);

    };

    /**

     *  Rebuilds the object from an xml formatted string

     *    @param xml_str The xml-formatted string

     *

     *    @return 0 on success, -1 otherwise

     */

    int from_xml(const string &xml_str);

protected:

    // *************************************************************************

    // Constructor

    // *************************************************************************

    VMTemplate(int id, int uid, string _user_name,

                   VirtualMachineTemplate * _template_contents);

    ~VMTemplate();

    // *************************************************************************

    // DataBase implementation

    // *************************************************************************

    static const char * db_names;

    static const char * db_bootstrap;

    static const char * table;

    /**

     *  Writes the VMTemplate in the database.

     *    @param db pointer to the db

     *    @return 0 on success

     */

    int insert(SqlDB *db, string& error_str);

    /**

     *  Writes/updates the VMTemplate data fields in the database.

     *    @param db pointer to the db

     *    @return 0 on success

     */

    int update(SqlDB *db)

    {

        return insert_replace(db, true);

    };

};

#endif /*VMTEMPLATE_H_*/

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

/* Copyright 2002-2011, OpenNebula Project Leads (OpenNebula.org)             */

/*                                                                            */

/* 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.                                             */

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

#ifndef VMTEMPLATE_POOL_H_

#define VMTEMPLATE_POOL_H_

#include "PoolSQL.h"

#include "VMTemplate.h"

/**

 *  The VMTemplate Pool class.

 */

class VMTemplatePool : public PoolSQL

{

public:

    VMTemplatePool(SqlDB * db) : PoolSQL(db, VMTemplate::table){};

    ~VMTemplatePool(){};

    /**

     *  Allocates a new object, writting it in the pool database. No memory is

     *  allocated for the object.

     *    @param uid user id (the owner of the Template)

     *    @param user_name Owner's user name

     *    @param template_contents a VM Template object

     *    @param oid the id assigned to the Template

     *    @param error_str Returns the error reason, if any

     *

     *    @return the oid assigned to the object, -1 in case of failure

     */

    int allocate(int                      uid,

                 string                   user_name,

                 VirtualMachineTemplate * template_contents,

                 int *                    oid,

                 string&                  error_str);

    /**

     *  Gets an object from the pool (if needed the object is loaded from the

     *  database).

     *   @param oid the object unique identifier

     *   @param lock locks the object if true

     *

     *   @return a pointer to the object, 0 in case of failure

     */

    VMTemplate * get(int oid, bool lock)

    {

        return static_cast<VMTemplate *>(PoolSQL::get(oid,lock));

    };

    /**

     *  Gets an object from the pool (if needed the object is loaded from the

     *  database).

     *   @param name of the object

     *   @param uid id of owner

     *   @param lock locks the object if true

     *

     *   @return a pointer to the object, 0 in case of failure

     */

    VMTemplate * get(const string& name, int uid, bool lock)

    {

        return static_cast<VMTemplate *>(PoolSQL::get(name,uid,lock));

    };

    /**

     *  Updates the object's data in the data base. The object mutex SHOULD be

     *  locked.

     *    @param objsql a pointer to the object

     *

     *    @return 0 on success.

     */

    int update(VMTemplate * vm_template)

    {

        return vm_template->update(db);

    };

    /**

     *  Drops the object's data in the data base. The object mutex SHOULD be

     *  locked.

     *    @param objsql a pointer to the object

     *    @return 0 on success.

     */

    int drop(VMTemplate * vm_template)

    {

        return PoolSQL::drop(vm_template);

    };

    /**

     *  Dumps the pool in XML format. A filter can be also added to the

     *  query

     *  @param oss the output stream to dump the pool contents

     *  @param where filter for the objects, defaults to all

     *

     *  @return 0 on success

     */

    int dump(ostringstream& oss, const string& where)

    {

        return PoolSQL::dump(oss, "TEMPLATE_POOL",VMTemplate::table,where);

    };

    /**

     *  Bootstraps the database table(s) associated to the pool

     */

    static void bootstrap(SqlDB *_db)

    {

        VMTemplate::bootstrap(_db);

    };

private:

    //--------------------------------------------------------------------------

    // Configuration Attributes for Images

    // -------------------------------------------------------------------------

    // TODO

    //--------------------------------------------------------------------------

    // Pool Attributes

    // -------------------------------------------------------------------------

    // TODO

    /**

     *  Factory method to produce Image objects

     *    @return a pointer to the new Image

     */

    PoolObjectSQL * create()

    {

        return new VMTemplate(-1,-1,"", 0);

    };

};

#endif /*VMTEMPLATE_POOL_H_*/

     *    @param user_name Owner's user name

     *    @param error_str Returns the error reason, if any

        case TEMPLATE: oss << "TEMPLATE:" ; break;

        VMTemplatePool::bootstrap(db);

        tpool = new VMTemplatePool(db);

            tpool,

    'nebula_vmtemplate',

    xmlrpc_c::methodPtr template_allocate(new

        RequestManager::TemplateAllocate(tpool,upool));

    xmlrpc_c::methodPtr template_delete(new

        RequestManager::TemplateDelete(tpool, upool));

    xmlrpc_c::methodPtr template_info(new

        RequestManager::TemplateInfo(tpool, upool));

    xmlrpc_c::methodPtr template_update(new

        RequestManager::TemplateUpdate(tpool, upool));

    xmlrpc_c::methodPtr template_rm_attribute(new

        RequestManager::TemplateRemoveAttribute(tpool, upool));

    xmlrpc_c::methodPtr template_publish(new

        RequestManager::TemplatePublish(tpool, upool));

    xmlrpc_c::methodPtr template_pool_info(new

        RequestManager::TemplatePoolInfo(tpool,upool));

    /* VM Template related methods*/

    RequestManagerRegistry.addMethod("one.template.allocate",template_allocate);

    RequestManagerRegistry.addMethod("one.templatepool.info",template_pool_info);

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

/* Copyright 2002-2011, OpenNebula Project Leads (OpenNebula.org)             */

/*                                                                            */

/* 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 "RequestManager.h"

#include "NebulaLog.h"

#include "Nebula.h"

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

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

void RequestManager::TemplateAllocate::execute(

    xmlrpc_c::paramList const& paramList,

    xmlrpc_c::value *   const  retval)

{

    string              session;

    string              str_template;

    string              error_str;

    string              user_name;

    const string        method_name = "TemplateAllocate";

    int                 oid, uid;

    int                 rc;

    ostringstream       oss;

    vector<xmlrpc_c::value> arrayData;

    xmlrpc_c::value_array * arrayresult;

    VirtualMachineTemplate * template_contents;

    User *                   user;

    char *                   error_msg = 0;

    NebulaLog::log("ReM",Log::DEBUG,"TemplateAllocate invoked");

    session      = xmlrpc_c::value_string(paramList.getString(0));

    str_template = xmlrpc_c::value_string(paramList.getString(1));

    str_template += "\n";

    //--------------------------------------------------------------------------

    //   Authenticate the user

    //--------------------------------------------------------------------------

    uid = TemplateAllocate::upool->authenticate(session);

    if (uid == -1)

    {

        goto error_authenticate;

    }

    //--------------------------------------------------------------------------

    //   Check the template syntax

    //--------------------------------------------------------------------------

    template_contents = new VirtualMachineTemplate;

    rc = template_contents->parse(str_template,&error_msg);

    if ( rc != 0 )

    {

        goto error_parse;

    }

    //--------------------------------------------------------------------------

    //   Authorize this request

    //--------------------------------------------------------------------------

    if ( uid != 0 )

    {

        AuthRequest ar(uid);

        string      t64;

        ar.add_auth(AuthRequest::TEMPLATE,

                    template_contents->to_xml(t64),

                    AuthRequest::CREATE,

                    uid,

                    false);

        if (UserPool::authorize(ar) == -1)

        {

            goto error_authorize;

        }

    }

    //--------------------------------------------------------------------------

    //   Get the User Name

    //--------------------------------------------------------------------------

    user = TemplateAllocate::upool->get(uid,true);

    if ( user == 0 )

    {

        goto error_user_get;

    }

    user_name = user->get_name();

    user->unlock();

    //--------------------------------------------------------------------------

    //   Allocate the VMTemplate

    //--------------------------------------------------------------------------

    rc = TemplateAllocate::tpool->allocate(uid,

                                           user_name,

                                           template_contents,

                                           &oid,

                                           error_str);

    if ( rc < 0 )

    {

        goto error_allocate;

    }

    arrayData.push_back(xmlrpc_c::value_boolean(true));

    arrayData.push_back(xmlrpc_c::value_int(oid));

    // Copy arrayresult into retval mem space

    arrayresult = new xmlrpc_c::value_array(arrayData);

    *retval = *arrayresult;

    delete arrayresult; // and get rid of the original

    return;

error_user_get:

    oss.str(get_error(method_name, "USER", uid));

    delete template_contents;

    goto error_common;

error_authenticate:

    oss.str(authenticate_error(method_name));

    goto error_common;

error_authorize:

    oss.str(authorization_error(method_name, "CREATE", "TEMPLATE", uid, -1));

    delete template_contents;

    goto error_common;

error_parse:

    oss << action_error(method_name, "PARSE", "VM TEMPLATE",-2,rc);

    if (error_msg != 0)

    {

        oss << ". Reason: " << error_msg;

        free(error_msg);

    }

    delete template_contents;

    goto error_common;

error_allocate:

    oss << action_error(method_name, "CREATE", "TEMPLATE", -2, 0);

    oss << " " << error_str;

    goto error_common;

error_common:

    arrayData.push_back(xmlrpc_c::value_boolean(false));  // FAILURE

    arrayData.push_back(xmlrpc_c::value_string(oss.str()));

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

    xmlrpc_c::value_array arrayresult_error(arrayData);

    *retval = arrayresult_error;

    return;

}

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

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

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

/* Copyright 2002-2011, OpenNebula Project Leads (OpenNebula.org)             */

/*                                                                            */

/* 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 "RequestManager.h"

#include "NebulaLog.h"

#include "Nebula.h"

#include "AuthManager.h"

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

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

void RequestManager::TemplateDelete::execute(

    xmlrpc_c::paramList const& paramList,

    xmlrpc_c::value *   const  retval)

{

    string              session;

    int                 oid;

    int                 uid;

    int                 rc;

    int                 owner;

    bool                is_public;

    VMTemplate *        vm_template;

    ostringstream       oss;

    const string        method_name = "TemplateDelete";

    vector<xmlrpc_c::value> arrayData;

    xmlrpc_c::value_array * arrayresult;

    NebulaLog::log("ReM",Log::DEBUG,"TemplateDelete invoked");

    session  = xmlrpc_c::value_string(paramList.getString(0));

    oid      = xmlrpc_c::value_int   (paramList.getInt(1));

    // First, we need to authenticate the user

    uid = TemplateDelete::upool->authenticate(session);

    if ( uid == -1 )

    {

        goto error_authenticate;

    }

    // Get template from the pool

    vm_template = TemplateDelete::tpool->get(oid,true);

    if ( vm_template == 0 )

    {

        goto error_get;

    }

    owner       = vm_template->get_uid();

    is_public   = vm_template->isPublic();

    vm_template->unlock();

    //Authorize the operation

    if ( uid != 0 ) // uid == 0 means oneadmin

    {

        AuthRequest ar(uid);

        ar.add_auth(AuthRequest::TEMPLATE,

                    oid,

                    AuthRequest::DELETE,

                    owner,

                    is_public);

        if (UserPool::authorize(ar) == -1)

        {

            goto error_authorize;

        }

    }

    // Get template from the pool

    vm_template = TemplateDelete::tpool->get(oid,true);

    if ( vm_template == 0 )

    {

        goto error_get;

    }

    rc = TemplateDelete::tpool->drop(vm_template);

    vm_template->unlock();

    if ( rc < 0 )

    {

        goto error_delete;

    }

    arrayData.push_back(xmlrpc_c::value_boolean(true));

    arrayData.push_back(xmlrpc_c::value_int(oid));

    // Copy arrayresult into retval mem space

    arrayresult = new xmlrpc_c::value_array(arrayData);

    *retval = *arrayresult;

    delete arrayresult; // and get rid of the original

    return;

error_authenticate:

    oss.str(authenticate_error(method_name));

    goto error_common;

error_get:

    oss.str(get_error(method_name, "TEMPLATE", oid));

    goto error_common;

error_authorize:

    oss.str(authorization_error(method_name, "DELETE", "TEMPLATE", uid, oid));

    goto error_common;

error_delete:

    oss.str(action_error(method_name, "DELETE", "TEMPLATE", oid, rc));

    vm_template->unlock();

    goto error_common;

error_common:

    arrayData.push_back(xmlrpc_c::value_boolean(false));  // FAILURE

    arrayData.push_back(xmlrpc_c::value_string(oss.str()));

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

    xmlrpc_c::value_array arrayresult_error(arrayData);

    *retval = arrayresult_error;

    return;

}

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

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

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

/* Copyright 2002-2011, OpenNebula Project Leads (OpenNebula.org)             */

/*                                                                            */

/* 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 "RequestManager.h"

#include "NebulaLog.h"

#include "AuthManager.h"

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

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

void RequestManager::TemplateInfo::execute(

    xmlrpc_c::paramList const& paramList,

    xmlrpc_c::value *   const  retval)

{

    string  session;

    int           oid;

    int           uid;     // owner user id

    int           rc;      // Requesting user id

    VMTemplate  * vm_template;

    ostringstream oss;

    const string  method_name = "TemplateInfo";

    /*   -- RPC specific vars --  */

    vector<xmlrpc_c::value> arrayData;

    xmlrpc_c::value_array * arrayresult;

    NebulaLog::log("ReM",Log::DEBUG,"TemplateInfo method invoked");

    // Get the parameters

    session      = xmlrpc_c::value_string(paramList.getString(0));

    oid          = xmlrpc_c::value_int   (paramList.getInt(1));

    // Get template from the pool

    vm_template = TemplateInfo::tpool->get(oid,true);

    if ( vm_template == 0 )

    {

        goto error_get;

    }

    uid = vm_template->get_uid();

    // Check if it is a valid user

    rc = TemplateInfo::upool->authenticate(session);

    if ( rc == -1 )

    {

        goto error_authenticate;

    }

    oss << *vm_template;

    vm_template->unlock();

    // All nice, return the host info to the client

    arrayData.push_back(xmlrpc_c::value_boolean(true)); // SUCCESS

    arrayData.push_back(xmlrpc_c::value_string(oss.str()));

    // Copy arrayresult into retval mem space

    arrayresult = new xmlrpc_c::value_array(arrayData);

    *retval = *arrayresult;

    delete arrayresult; // and get rid of the original

    return;

error_get:

    oss.str(get_error(method_name, "TEMPLATE", oid));

    goto error_common;

error_authenticate:

    oss.str(authenticate_error(method_name));

    vm_template->unlock();

    goto error_common;

error_common:

    arrayData.push_back(xmlrpc_c::value_boolean(false)); // FAILURE

    arrayData.push_back(xmlrpc_c::value_string(oss.str()));

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

    xmlrpc_c::value_array arrayresult_error(arrayData);

    *retval = arrayresult_error;

    return;

}

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

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

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

/* Copyright 2002-2011, OpenNebula Project Leads (OpenNebula.org)             */

/*                                                                            */

/* 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 "RequestManager.h"

#include "NebulaLog.h"

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

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

void RequestManager::TemplatePoolInfo::execute(

    xmlrpc_c::paramList const& paramList,

    xmlrpc_c::value *   const  retval)

{

    string        session;

    ostringstream oss;

    ostringstream where_string;

    int           rc;

    int           filter_flag;

    const string  method_name = "TemplatePoolInfo";

    /*   -- RPC specific vars --  */

    vector<xmlrpc_c::value> arrayData;

    xmlrpc_c::value_array * arrayresult;

    NebulaLog::log("ReM",Log::DEBUG,"TemplatePoolInfo method invoked");

    // Get the parameters

    session     = xmlrpc_c::value_string(paramList.getString(0));

    filter_flag = xmlrpc_c::value_int(paramList.getInt(1));

    // Check if it is a valid user

    rc = TemplatePoolInfo::upool->authenticate(session);

    if ( rc == -1 )

    {

        goto error_authenticate;

    }

    /** Filter flag meaning table

     *      -2 :: All Templates

     *      -1 :: User's Templates AND public templates belonging to any user

     *    >= 0 :: UID User's Templates

     **/

    if ( filter_flag < -2 )

    {

        goto error_filter_flag;

    }

    switch(filter_flag)

    {

        case -2:

            break;

        case -1:

            where_string << "UID=" << rc << " OR PUBLIC=1";

            break;

        default:

            where_string << "UID=" << filter_flag;

    }

    // Call the template pool dump

    rc = TemplatePoolInfo::tpool->dump(oss,where_string.str());

    if ( rc != 0 )

    {

        goto error_dump;

    }

    // All nice, return pool info to the client

    arrayData.push_back(xmlrpc_c::value_boolean(true)); // SUCCESS

    arrayData.push_back(xmlrpc_c::value_string(oss.str()));

    arrayresult = new xmlrpc_c::value_array(arrayData);

    // Copy arrayresult into retval mem space

    *retval = *arrayresult;

    // and get rid of the original

    delete arrayresult;

    return;

error_authenticate:

    oss.str(authenticate_error(method_name));

    goto error_common;

error_filter_flag:

    oss << "Incorrect filter_flag, must be >= -2.";

    goto error_common;

error_dump:

    oss.str(get_error(method_name, "TEMPLATE", -1));

    goto error_common;

error_common:

    arrayData.push_back(xmlrpc_c::value_boolean(false)); // FAILURE

    arrayData.push_back(xmlrpc_c::value_string(oss.str()));

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

    xmlrpc_c::value_array arrayresult_error(arrayData);

    *retval = arrayresult_error;

    return;

}

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

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

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

/* Copyright 2002-2011, OpenNebula Project Leads (OpenNebula.org)             */

/*                                                                            */

/* 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 "RequestManager.h"

#include "NebulaLog.h"

#include "Nebula.h"

#include "AuthManager.h"

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

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